@sockethub/server 5.0.0-alpha.3

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@sockethub/server",
+  "description": "A polyglot messaging service, server libraries",
+  "version": "5.0.0-alpha.3",
+  "private": false,
+  "author": "Nick Jennings <nick@silverbucket.net>",
+  "license": "LGPL-3.0+",
+  "main": "dist/index.js",
+  "bin": "bin/sockethub",
+  "preferGlobal": true,
+  "keywords": [
+    "sockethub",
+    "messaging",
+    "polyglot",
+    "unhosted",
+    "apis",
+    "api",
+    "protocols",
+    "protocol",
+    "irc",
+    "xmpp",
+    "facebook",
+    "rss",
+    "atom",
+    "twitter",
+    "smtp",
+    "imap",
+    "email"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sockethub/sockethub.git",
+    "directory": "packages/server"
+  },
+  "homepage": "https://sockethub.org",
+  "dependencies": {
+    "@sockethub/activity-streams": "^4.4.0-alpha.3",
+    "@sockethub/client": "^5.0.0-alpha.3",
+    "@sockethub/schemas": "^3.0.0-alpha.3",
+    "body-parser": "^1.19.0",
+    "bull": "^4.0.0",
+    "debug": "^4.3.1",
+    "ejs": "^3.0.1",
+    "express": "^4.17.1",
+    "findup-sync": "^5.0.0",
+    "jquery": "^3.4.1",
+    "nconf": "^0.11.2",
+    "npm": "8.5.4",
+    "object-hash": "^3.0.0",
+    "secure-store-redis": "^1.4.7",
+    "socket.io": "^4.0.1",
+    "urijs": "^1.19.2"
+  },
+  "scripts": {
+    "clean": "npx rimraf dist coverage",
+    "clean:deps": "npx rimraf node_modules",
+    "compliance": "yarn run lint && yarn run test && yarn run coverage",
+    "test": "c8 -x src/bootstrap -x \"src/**/*.test.*\" mocha -r ts-node/register src/*.test.ts src/**/*.test.ts",
+    "coverage": "c8 check-coverage --statements 90 --branches 80 --functions 90 --lines 90",
+    "start": "DEBUG=sockethub* ./bin/sockethub",
+    "dev": "yarn run build && DEBUG=sockethub* ./bin/sockethub --examples",
+    "lint": "eslint \"**/*.ts\" ./bin/sockethub",
+    "lint:fix": "eslint --fix \"**/*.ts\" ./bin/sockethub",
+    "build": "npx rimraf dist && tsc && cp ./src/defaults.json ./dist/defaults.json && cp src/bootstrap/platforms.js dist/bootstrap/"
+  },
+  "engines": {
+    "node": ">= 12.4.0"
+  },
+  "devDependencies": {
+    "@types/body-parser": "1.19.2",
+    "@types/chai": "4.3.0",
+    "@types/debug": "4.1.7",
+    "@types/ejs": "3.1.0",
+    "@types/eslint": "8.4.1",
+    "@types/express": "4.17.13",
+    "@types/jquery": "3.5.13",
+    "@types/mocha": "9.1.0",
+    "@types/nconf": "0.10.1",
+    "@types/node": "17.0.13",
+    "@types/object-hash": "2.2.1",
+    "@types/proxyquire": "1.3.28",
+    "@types/sinon": "10.0.11",
+    "@types/urijs": "1.19.18",
+    "@typescript-eslint/parser": "5.12.1",
+    "c8": "7.11.0",
+    "chai": "4.3.6",
+    "eslint": "8.9.0",
+    "eslint-cli": "1.1.1",
+    "jaribu": "2.2.3",
+    "mocha": "9.2.1",
+    "proxyquire": "2.1.3",
+    "sinon": "13.0.1",
+    "ts-node": "10.5.0",
+    "typescript": "4.5.5"
+  },
+  "optionalDependencies": {
+    "@sockethub/platform-dummy": "^3.0.0-alpha.3",
+    "@sockethub/platform-feeds": "^3.0.0-alpha.3",
+    "@sockethub/platform-irc": "^4.0.0-alpha.3",
+    "@sockethub/platform-xmpp": "^5.0.0-alpha.3"
+  },
+  "gitHead": "f02238a478b7ffd3f31d8deea292eb67e630a86b"
+}

package/sockethub.config.example.json

@@ -0,0 +1,33 @@
+{
+  "activity-streams": {
+    "opts": {
+      "specialObjs": [ "credentials" ]
+    }
+  },
+  "examples": {
+    "enabled": false,
+    "secret": 1234567890
+  },
+  "sockethub": {
+    "port": 10550,
+    "host": "localhost",
+    "path": "/sockethub"
+  },
+  "log_file": "",
+  "platforms": [
+    "@sockethub/platform-dummy",
+    "@sockethub/platform-feeds",
+    "@sockethub/platform-irc",
+    "@sockethub/platform-xmpp"
+  ],
+  "public": {
+    "protocol": "http",
+    "host": "localhost",
+    "port": 10550,
+    "path": "/"
+  },
+  "redis": {
+    "host": "127.0.0.1",
+    "port": 6379
+  }
+}

package/src/bootstrap/init.d.ts

@@ -0,0 +1,8 @@
+declare const init: {
+    version: any;
+    platforms: Map<any, any>;
+    host: any;
+    port: any;
+    path: any;
+};
+export default init;

package/src/bootstrap/init.ts

@@ -0,0 +1,83 @@
+import debug from 'debug';
+
+import config from '../config';
+import platformLoad from './platforms';
+
+const log = debug('sockethub:server:bootstrap:init');
+log('running init routines');
+
+const packageJSON = require('./../../package.json');
+const platforms = platformLoad(config.get('platforms'));
+
+if (config.get('info')) {
+  // eslint-disable-next-line security-node/detect-crlf
+  console.log('sockethub ' + packageJSON.version);
+  console.log();
+
+  // eslint-disable-next-line security-node/detect-crlf
+  console.log('websocket: ws://' + config.get('sockethub:host') + ':'
+    + config.get('sockethub:port')
+    + config.get('sockethub:path'));
+
+  console.log();
+  // eslint-disable-next-line security-node/detect-crlf
+  console.log('examples: ' + (config.get('examples:enabled') ?
+    'http://' +
+    config.get('public:host') + ':' + config.get('public:port') + config.get('public:path')
+    : 'disabled'));
+
+  console.log();
+  if (config.get('redis:url')) {
+    // eslint-disable-next-line security-node/detect-crlf
+    console.log('redis URL: ' + config.get('redis:url'));
+  } else {
+    // eslint-disable-next-line security-node/detect-crlf
+    console.log('redis: ' + config.get('redis:host') + ':' + config.get('redis:port'));
+  }
+
+  console.log();
+  // eslint-disable-next-line security-node/detect-crlf
+  console.log('platforms: ' + Array.from(platforms.keys()).join(', '));
+
+  if (platforms.size > 0) {
+    for (let platform of platforms.values()) {
+      console.log();
+      // eslint-disable-next-line security-node/detect-crlf
+      console.log(platform.moduleName);
+      // eslint-disable-next-line security-node/detect-crlf
+      console.log(' name: ' + platform.id + ' version: ' + platform.version);
+      // eslint-disable-next-line security-node/detect-crlf
+      console.log(' AS types: ' + platform.types.join(', '));
+    }
+    console.log();
+    process.exit();
+  } else {
+    console.log();
+    process.exit();
+  }
+}
+
+log('finished init routines');
+
+export interface IInitObject {
+  version: string,
+  platforms: Map<string, {
+    id: string,
+    moduleName: string,
+    config: {
+      persist?: boolean
+    },
+    schemas: {
+      credentials?: object,
+      messages?: object
+    },
+    version: string,
+    types: Array<string>
+  }>,
+}
+
+const init: IInitObject = {
+  version: packageJSON.version,
+  platforms: platforms
+};
+export default init;

package/src/bootstrap/platforms.js

@@ -0,0 +1,75 @@
+/**
+ * bootstrap/platforms.js
+ *
+ * A Singleton responsible for finding and loading all valid Sockethub
+ * platforms, and whitelisting or blacklisting (or neither) based on the
+ * config.
+ */
+const debug   = require('debug'),
+      schemas = require('@sockethub/schemas').default;
+
+const log = debug('sockethub:server:bootstrap:platforms');
+
+log('loading platforms');
+
+// if the platform schema lists valid types it implements (essentially methods/verbs for
+// Sockethub to call) then add it to the supported types list.
+function platformListsSupportedTypes(p) {
+  return ((p.schema.messages.properties) && (p.schema.messages.properties.type) &&
+    (p.schema.messages.properties.type.enum) &&
+    (p.schema.messages.properties.type.enum.length > 0));
+}
+
+module.exports = function platformLoad(platformsList, requireModule) {
+  if (!requireModule) {
+    requireModule = require;
+  }
+  // load platforms from config.platforms
+  const platforms = new Map();
+
+  if (platformsList.length <= 0) {
+    throw new Error('No platforms defined. Please check your sockethub.config.json');
+  }
+
+  for (let moduleName of platformsList) {
+    log(`loading ${moduleName}`);
+    // try to load platform
+    // eslint-disable-next-line security-node/detect-non-literal-require-calls
+    const P = requireModule(moduleName);
+    const p = new P();
+    let types = [];
+
+    const err = schemas.validatePlatformSchema(p.schema);
+    if (err) {
+      throw new Error(`${moduleName} ${err}`);
+    } else if (typeof p.config !== 'object') {
+      throw new Error(
+        `${moduleName} platform must have a config property that is an object.`);
+    } else {
+      if (p.schema.credentials) {
+        // register the platforms credentials schema
+        types.push('credentials');
+      } else {
+        p.config.noCredentials = true;
+      }
+    }
+
+    if (platformListsSupportedTypes(p)) {
+      types = [...types, ...p.schema.messages.properties.type.enum];
+    }
+
+    const platformName = p.schema.name;
+    platforms.set(platformName, {
+      id: platformName,
+      moduleName: moduleName,
+      config: p.config,
+      schemas: {
+        credentials: p.schema.credentials || {},
+        messages: p.schema.messages || {}
+      },
+      version: p.schema.version,
+      types: types
+    });
+  }
+  return platforms;
+};

package/src/common.test.ts

@@ -0,0 +1,54 @@
+import proxyquire from 'proxyquire';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import { decryptJobData, getPlatformId } from './common';
+import crypto from './crypto';
+
+proxyquire.noPreserveCache();
+proxyquire.noCallThru();
+
+describe("getPlatformId", () => {
+  let cryptoHashStub: any;
+
+  beforeEach(() => {
+    cryptoHashStub = sinon.stub(crypto, 'hash');
+    cryptoHashStub.returnsArg(0);
+    proxyquire('./common', { crypto: { hash: cryptoHashStub }});
+  });
+
+  afterEach(() => {
+    cryptoHashStub.restore();
+  });
+
+  it('generates platform hash', () => {
+    expect(getPlatformId('foo')).to.be.equal('foo');
+    sinon.assert.calledOnce(cryptoHashStub);
+    sinon.assert.calledWith(cryptoHashStub, 'foo');
+  });
+  it('generates platform + actor hash', () => {
+    expect(getPlatformId('foo', 'bar')).to.be.equal('foobar');
+    sinon.assert.calledOnce(cryptoHashStub);
+    sinon.assert.calledWith(cryptoHashStub, 'foobar');
+  });
+});
+
+describe("decryptJobData", () => {
+  let cryptoDecryptStub: any;
+
+  beforeEach(() => {
+    cryptoDecryptStub = sinon.stub(crypto, 'decrypt');
+    cryptoDecryptStub.returnsArg(0);
+    proxyquire('./common', { crypto: { hash: cryptoDecryptStub }});
+  });
+
+  afterEach(() => {
+    cryptoDecryptStub.restore();
+  });
+
+  it("decrypts and returns expected object", () => {
+    const jobData = {data:{title:"foo", msg:'encryptedjobdata', sessionId:'foobar'}};
+    const secret = 'secretstring';
+    expect(decryptJobData(jobData, secret)).to.be.eql(jobData.data);
+  });
+});

package/src/common.ts

@@ -0,0 +1,14 @@
+import crypto from "./crypto";
+import { JobDataDecrypted, JobEncrypted } from "./sockethub";
+
+export function getPlatformId(platform: string, actor?: string): string {
+  return actor ? crypto.hash(platform + actor) : crypto.hash(platform);
+}
+
+export function decryptJobData(job: JobEncrypted, secret: string): JobDataDecrypted {
+  return {
+    title: job.data.title,
+    msg: crypto.decrypt(job.data.msg, secret),
+    sessionId: job.data.sessionId
+  };
+}

package/src/config.d.ts

@@ -0,0 +1,2 @@
+declare let config: any;
+export default config;

package/src/config.test.ts

@@ -0,0 +1,28 @@
+import { expect } from 'chai';
+
+import { Config } from './config';
+
+describe('config', () => {
+
+  it('loads default values', () => {
+    const config = new Config();
+    expect(config).to.have.property('get');
+    expect(config.get('sockethub:host')).to.eql('localhost');
+  });
+
+  it('overrides from env', () => {
+    const hostname = 'a host string';
+    process.env = { HOST: hostname };
+    const config = new Config();
+    expect(config).to.have.property('get');
+    expect(config.get('sockethub:host')).to.eql(hostname);
+  });
+
+  it('defaults to redis config', () => {
+    process.env = { REDIS_URL: '' };
+    const config = new Config();
+    expect(config).to.have.property('get');
+    expect(config.get('redis')).to.eql(
+      {"host": "127.0.0.1", "port": 6379});
+  });
+});

package/src/config.ts

@@ -0,0 +1,94 @@
+import nconf from 'nconf';
+import { debug } from 'debug';
+import * as fs from "fs";
+
+const log = debug('sockethub:server:bootstrap:config');
+
+export class Config {
+  constructor() {
+    log('initializing config');
+    // assign config loading priorities (command-line, environment, cfg, defaults)
+    nconf.argv({
+      'info': {
+        type: 'boolean',
+        describe: 'Display Sockethub runtime information'
+      },
+      'examples': {
+        type: 'boolean',
+        describe: 'Enable the examples pages served at [host]:[port]/examples'
+      },
+      'config': {
+        alias: 'c',
+        default: '',
+        describe: 'Path to sockethub.config.json'
+      },
+      'port': {
+        alias: 'sockethub.port'
+      },
+      'host': {
+        alias: 'sockethub.host'
+      },
+      'redis_host': {
+        alias: 'redis.host'
+      },
+      'redis_port': {
+        alias: 'redis.port'
+      },
+      'redis_url': {
+        alias: 'redis.url'
+      }
+    });
+    nconf.env();
+
+    // get value of flags defined by any command-line params
+    const examples = nconf.get('examples');
+
+    // Load the main config
+    let configFile = nconf.get('config');
+    if (configFile) {
+      if (! fs.existsSync(configFile)) {
+        throw new Error(`Config file not found: ${configFile}`);
+      }
+    } else {
+      configFile = __dirname + '/../sockethub.config.json';
+    }
+    nconf.file(configFile);
+
+    // only override config file if explicitly mentioned in command-line params
+    nconf.set('examples:enabled', (examples ? true : nconf.get('examples:enabled')));
+
+    // load defaults
+    const defaults: object = require(__dirname + '/defaults.json');
+    nconf.defaults(defaults);
+
+    nconf.required(['platforms']);
+
+    function defaultEnvParams(host: string, port: string | number, prop: string) {
+      nconf.set(prop + ':host', host);
+      nconf.set(prop + ':port', port);
+    }
+
+    defaultEnvParams(
+      process.env.HOST || nconf.get('sockethub:host'),
+      process.env.PORT || nconf.get('sockethub:port'),
+      'sockethub'
+    );
+
+    defaultEnvParams(
+      process.env.REDIS_HOST || nconf.get('redis:host'),
+      process.env.REDIS_PORT || nconf.get('redis:port'),
+      'redis'
+    );
+
+    // allow a redis://user:host:port url, takes precedence
+    if (process.env.REDIS_URL) {
+      nconf.set('redis:url', process.env.REDIS_URL);
+      nconf.clear('redis:host');
+      nconf.clear('redis:port');
+    }
+  }
+  get = (key: string): any => nconf.get(key);
+}
+
+const config = new Config();
+export default config;

package/src/crypto.d.ts

@@ -0,0 +1,5 @@
+declare const crypto: {
+    encrypt: (json: any, secret: any) => string;
+    decrypt: (string: any, secret: any) => any;
+};
+export default crypto;

package/src/crypto.test.ts

@@ -0,0 +1,41 @@
+import { expect } from 'chai';
+import proxyquire from 'proxyquire';
+
+const crypto = proxyquire('./crypto', {
+  'crypto': {
+    randomBytes: () => Buffer.alloc(16)
+  }
+}).default;
+
+const secret = 'a test secret.. that is 16 x 2..';
+const data = {'foo': 'bar'};
+const encryptedData = "00000000000000000000000000000000:0543ec94d863fbf4b7a19b48e69d9317";
+
+describe('crypto', () => {
+  it('encrypts', () => {
+    expect(crypto.encrypt(data, secret)).to.be.equal(encryptedData);
+  });
+  it('decrypts', () => {
+    expect(crypto.decrypt(encryptedData, secret)).to.eql(data);
+  });
+  it('hashes', () => {
+    expect(crypto.hash('foobar')).to.be.equal('8843d7f');
+  });
+  it('randTokens 8', () => {
+    const token = crypto.randToken(8);
+    expect(token.length).to.be.equal(8);
+  });
+  it('randTokens 16', () => {
+    const token = crypto.randToken(16);
+    expect(token.length).to.be.equal(16);
+  });
+  it('randTokens 32', () => {
+    const token = crypto.randToken(32);
+    expect(token.length).to.be.equal(32);
+  });
+  it('randTokens 33+ will fail', () => {
+    expect(() => {
+      crypto.randToken(33);
+    }).to.throw();
+  });
+});

package/src/crypto.ts

@@ -0,0 +1,41 @@
+import { randomBytes, createCipheriv, createDecipheriv, createHash } from 'crypto';
+import { IActivityStream } from "@sockethub/schemas";
+
+const ALGORITHM = 'aes-256-cbc',
+      IV_LENGTH = 16; // For AES, this is always 16
+
+class Crypto {
+  constructor() {}
+  encrypt(json: IActivityStream, secret: string): string {
+    const iv = randomBytes(IV_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, Buffer.from(secret), iv);
+    let encrypted = cipher.update(JSON.stringify(json));
+
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return iv.toString('hex') + ':' + encrypted.toString('hex');
+  }
+  decrypt(text: string, secret: string): IActivityStream {
+    let parts = text.split(':');
+    const iv = Buffer.from(parts.shift(), 'hex');
+    const encryptedText = Buffer.from(parts.join(':'), 'hex');
+    const decipher = createDecipheriv(ALGORITHM, Buffer.from(secret), iv);
+    let decrypted = decipher.update(encryptedText);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return JSON.parse(decrypted.toString());
+  }
+  hash(text: string): string {
+    const shasum = createHash('sha1');
+    shasum.update(text);
+    return shasum.digest('hex').substring(0, 7);
+  }
+  randToken(len: number): string {
+    if (len > 32) {
+      throw new Error(`crypto.randToken supports a length param of up to 32, ${len} given`);
+    }
+    const buf = randomBytes(len);
+    return buf.toString('hex').substring(0, len);
+  }
+}
+
+const crypto = new Crypto();
+export default crypto;

package/src/defaults.json

@@ -0,0 +1,28 @@
+{
+  "activity-streams": {
+    "opts": {
+      "specialObjs": [ "credentials" ]
+    }
+  },
+  "examples": {
+    "enabled": false,
+    "secret": 1234567890
+  },
+  "sockethub": {
+    "port": 10550,
+    "host": "localhost",
+    "path": "/sockethub"
+  },
+  "log_file": "",
+  "platforms": [],
+  "public": {
+    "protocol": "http",
+    "host": "localhost",
+    "port": 10550,
+    "path": "/"
+  },
+  "redis": {
+    "host": "127.0.0.1",
+    "port": 6379
+  }
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+const Sockethub = require('./sockethub').default;
+const sockethub = new Sockethub();
+
+module.exports = async () => {
+  process.once('uncaughtException', function (err) {
+    console.log('UNCAUGHT EXCEPTION');
+    // eslint-disable-next-line security-node/detect-crlf
+    console.log(err.stack);
+    process.exit(1);
+  });
+
+  process.once('SIGTERM', function () {
+    console.log('Received TERM signal. Exiting.');
+    process.exit(0);
+  });
+
+  process.once('SIGINT', function () {
+    console.log('Received INT signal. Exiting.');
+    process.exit(0);
+  });
+
+  process.once('exit', async function () {
+    console.log('destroying all platform instances');
+    await sockethub.removeAllPlatformInstances();
+  });
+
+  sockethub.boot();
+};

package/src/janitor.d.ts

@@ -0,0 +1,8 @@
+declare function janitorCycle(): void;
+declare const janitor: {
+    start: typeof janitorCycle;
+    alreadyCalled: boolean;
+    cycleCount: number;
+    reportCount: number;
+};
+export default janitor;