enigma-bbs/core/activitypub/actor.js

306 lines
9.2 KiB
JavaScript

/* jslint node: true */
'use strict';
// ENiGMA½
const { Errors } = require('../enig_error.js');
const UserProps = require('../user_property');
const Endpoints = require('./endpoint');
const { userNameFromSubject, isValidLink } = require('./util');
const Log = require('../logger').log;
const { queryWebFinger } = require('../webfinger');
const EnigAssert = require('../enigma_assert');
const ActivityPubSettings = require('./settings');
const ActivityPubObject = require('./object');
const { ActivityStreamMediaType, Collections } = require('./const');
const Config = require('../config').get;
// deps
const _ = require('lodash');
const mimeTypes = require('mime-types');
const { getJson } = require('../http_util.js');
const moment = require('moment');
const paths = require('path');
const Collection = require('./collection.js');
const ActorCacheExpiration = moment.duration(15, 'days');
const ActorCacheMaxAgeDays = 125; // hasn't been used in >= 125 days, nuke it.
// default context for Actor's
const DefaultContext = ActivityPubObject.makeContext(['https://w3id.org/security/v1'], {
toot: 'http://joinmastodon.org/ns#',
discoverable: 'toot:discoverable',
manuallyApprovesFollowers: 'as:manuallyApprovesFollowers',
});
// https://www.w3.org/TR/activitypub/#actor-objects
module.exports = class Actor extends ActivityPubObject {
constructor(obj, withContext = DefaultContext) {
super(obj, withContext);
}
isValid() {
if (!super.isValid()) {
return false;
}
if (!Actor.WellKnownActorTypes.includes(this.type)) {
return false;
}
const linksValid = Actor.WellKnownLinkTypes.every(l => {
// must be valid if present & non-empty
if (this[l] && !isValidLink(this[l])) {
return false;
}
return true;
});
if (!linksValid) {
return false;
}
return true;
}
static fromJsonString(s) {
const obj = ActivityPubObject.fromJsonString(s);
return new Actor(obj);
}
static get WellKnownActorTypes() {
return ['Person', 'Group', 'Organization', 'Service', 'Application'];
}
static get WellKnownLinkTypes() {
return [
Collections.Inbox,
Collections.Outbox,
Collections.Following,
Collections.Followers,
];
}
static fromLocalUser(user, cb) {
const userActorId = user.getProperty(UserProps.ActivityPubActorId);
if (!userActorId) {
return cb(
Errors.MissingProperty(
`User missing '${UserProps.ActivityPubActorId}' property`
)
);
}
const userSettings = ActivityPubSettings.fromUser(user);
const addImage = (o, t) => {
const url = userSettings[t];
if (url) {
const fn = paths.basename(url);
const mt = mimeTypes.contentType(fn);
if (mt) {
o[t] = {
mediaType: mt,
type: 'Image',
url,
};
}
}
};
const obj = {
id: userActorId,
type: 'Person',
preferredUsername: user.username,
name: userSettings.showRealName
? user.getSanitizedName('real')
: user.username,
endpoints: {
sharedInbox: Endpoints.sharedInbox(),
},
inbox: Endpoints.inbox(user),
outbox: Endpoints.outbox(user),
followers: Endpoints.followers(user),
following: Endpoints.following(user),
summary: user.getProperty(UserProps.AutoSignature) || '',
url: Endpoints.profile(user),
manuallyApprovesFollowers: userSettings.manuallyApprovesFollowers,
discoverable: userSettings.discoverable,
// :TODO: we can start to define BBS related stuff with the community perhaps
// attachment: [
// {
// name: 'SomeNetwork Address',
// type: 'PropertyValue',
// value: 'Mateo@21:1/121',
// },
// ],
// :TODO: re-enable once a spec is defined; board should prob be a object with connection info, etc.
// bbsInfo: {
// boardName: Config().general.boardName,
// memberSince: user.getProperty(UserProps.AccountCreated),
// affiliations: user.getProperty(UserProps.Affiliations) || '',
// },
};
addImage(obj, 'icon');
addImage(obj, 'image');
const publicKeyPem = user.getProperty(UserProps.PublicActivityPubSigningKey);
if (!_.isEmpty(publicKeyPem)) {
obj.publicKey = {
id: userActorId + '#main-key',
owner: userActorId,
publicKeyPem,
};
EnigAssert(
!_.isEmpty(user.getProperty(UserProps.PrivateActivityPubSigningKey)),
'User has public key but no private key!'
);
} else {
Log.warn(
{ username: user.username },
`No public key (${UserProps.PublicActivityPubSigningKey}) for user "${user.username}"`
);
}
return cb(null, new Actor(obj));
}
static fromId(id, cb) {
let delivered = false;
const callback = (e, a, s) => {
if (!delivered) {
delivered = true;
return cb(e, a, s);
}
};
if (!id) {
return cb(Errors.Invalid('Invalid Actor ID'));
}
Actor._fromCache(id, (err, actor, subject, needsRefresh) => {
if (!err) {
// cache hit
callback(null, actor, subject);
if (!needsRefresh) {
return;
}
}
// Cache miss or needs refreshed; Try to do so now
Actor._fromWebFinger(id, (err, actor, subject) => {
if (err) {
return callback(err);
}
if (subject) {
subject = `@${userNameFromSubject(subject)}`; // e.g. @Username@host.com
} else if (!_.isEmpty(actor)) {
subject = actor.id; // best we can do for now
}
// deliver result to caller
callback(err, actor, subject);
// cache our entry
if (actor) {
Collection.addActor(actor, subject, err => {
if (err) {
// :TODO: Log me
}
});
}
});
});
}
static actorCacheMaintenanceTask(args, cb) {
const enabled = _.get(
Config(),
'contentServers.web.handlers.activityPub.enabled'
);
if (!enabled) {
return;
}
Collection.removeExpiredActors(ActorCacheMaxAgeDays, err => {
if (err) {
Log.error('Failed removing expired Actor items');
}
return cb(null); // always non-fatal
});
}
static _fromRemoteQuery(id, cb) {
const headers = {
Accept: ActivityStreamMediaType,
};
getJson(id, { headers }, (err, actor) => {
if (err) {
return cb(err);
}
actor = new Actor(actor);
if (!actor.isValid()) {
return cb(Errors.Invalid('Invalid Actor'));
}
return cb(null, actor);
});
}
static _fromCache(actorIdOrSubject, cb) {
Collection.actor(actorIdOrSubject, (err, actor, info) => {
if (err) {
return cb(err);
}
const needsRefresh = moment().isAfter(
info.timestamp.add(ActorCacheExpiration)
);
actor = new Actor(actor);
if (!actor.isValid()) {
return cb(Errors.Invalid('Failed to create Actor object'));
}
return cb(null, actor, info.subject, needsRefresh);
});
}
static _fromWebFinger(actorQuery, cb) {
queryWebFinger(actorQuery, (err, res) => {
if (err) {
return cb(err);
}
// we need a link with 'application/activity+json'
const links = res.links;
if (!Array.isArray(links)) {
return cb(Errors.DoesNotExist('No "links" object in WebFinger response'));
}
const activityLink = links.find(l => {
return l.type === ActivityStreamMediaType && l.href?.length > 0;
});
if (!activityLink) {
return cb(
Errors.DoesNotExist('No Activity link found in WebFinger response')
);
}
// we can now query the href value for an Actor
return Actor._fromRemoteQuery(activityLink.href, (err, actor) => {
return cb(err, actor, res.subject);
});
});
}
};