@sockethub/server 5.0.0-alpha.4 → 5.0.0-alpha.6

package/src/bootstrap/init.ts

@@ -1,84 +1,160 @@
-import debug from 'debug';
-
-import config from '../config';
-import platformLoad from './platforms';
-
-const log = debug('sockethub:server:bootstrap:init');
-log('running init routines');
-
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-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 (const 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(', '));
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import debug from "debug";
+
+import { type RedisConfig, redisCheck } from "@sockethub/data-layer";
+
+import { addPlatformSchema } from "@sockethub/schemas";
+import config from "../config.js";
+import loadPlatforms, {
+    type PlatformMap,
+    type PlatformStruct,
+} from "./load-platforms.js";
+
+const log = debug("sockethub:server:bootstrap:init");
+
+export interface IInitObject {
+    version: string;
+    platforms: PlatformMap;
+}
+
+let init: IInitObject;
+
+function getExecutablePath(): string {
+    // Primary: use the actual invoked script path
+    if (process.argv[1]) {
+        return process.argv[1];
+    }
+    // Fallback: resolve from import.meta.url
+    return fileURLToPath(import.meta.url);
+}
+
+export function printSettingsInfo(
+    version: string,
+    platforms: Map<string, PlatformStruct>,
+) {
+    const execPath = getExecutablePath();
+
+    console.log(`${chalk.cyan("sockethub")} ${version}`);
+    console.log(`${chalk.cyan("executable:")} ${execPath}`);
+
+    const wsUrl = `ws://${config.get("sockethub:host")}:${config.get("sockethub:port")}${config.get("sockethub:path")}`;
+    console.log(`${chalk.cyan("websocket:")} ${chalk.blue(wsUrl)}`);
+
+    const examplesUrl = `http://${config.get("public:host")}:${config.get(
+        "public:port",
+    )}${config.get("public:path")}`;
+    console.log(
+        `${chalk.cyan("examples:")} ${config.get("examples") ? chalk.blue(examplesUrl) : "disabled"}`,
+    );
+
+    console.log(
+        `${chalk.cyan("redis URL:")} ${chalk.blue(config.get("redis:url"))}`,
+    );
+
+    console.log(
+        `${chalk.cyan("platforms:")} ${Array.from(platforms.keys()).join(", ")}`,
+    );
+
+    if (platforms.size > 0) {
+        for (const platform of platforms.values()) {
+            console.log();
+            console.log(chalk.green(`- ${platform.moduleName}`));
+            console.log(` ${chalk.dim("version:")} ${platform.version}`);
+            console.log(
+                ` ${chalk.dim("AS types:")} ${platform.types.map((t) => chalk.yellow(t)).join(", ")}`,
+            );
+            if (platform.modulePath) {
+                console.log(` ${chalk.dim("path:")} ${platform.modulePath}`);
+            }
+        }
     }
     console.log();
     process.exit();
-  } else {
-    console.log();
-    process.exit();
-  }
 }
 
-log('finished init routines');
+let initCalled = false;
+let initWaitCount = 0;
+let cancelWait: Timer;
+const resolveQueue = [];
 
-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>
-  }>,
+export default async function getInitObject(
+    initFunc: () => Promise<IInitObject> = __loadInit,
+): Promise<IInitObject> {
+    return new Promise((resolve, reject) => {
+        if (initCalled) {
+            if (init) {
+                resolve(init);
+            } else if (!cancelWait) {
+                cancelWait = setInterval(() => {
+                    if (!init) {
+                        if (initWaitCount > 10) {
+                            reject("failed to initialize");
+                        }
+                        initWaitCount++;
+                    } else {
+                        clearInterval(cancelWait);
+                        resolve(init);
+                        for (const resolve of resolveQueue) {
+                            resolve(init);
+                        }
+                    }
+                }, 1000);
+            } else {
+                resolveQueue.push(resolve);
+            }
+        } else {
+            initCalled = true;
+            if (init) {
+                resolve(init);
+            } else {
+                initFunc()
+                    .then((_init) => {
+                        init = _init;
+                        return registerPlatforms(_init);
+                    })
+                    .then(() => {
+                        resolve(init);
+                    });
+            }
+        }
+    });
 }
 
-const init: IInitObject = {
-  version: packageJSON.version,
-  platforms: platforms
-};
-export default init;
+export async function registerPlatforms(initObj: IInitObject): Promise<void> {
+    for (const [_, platform] of initObj.platforms) {
+        for (const key of Object.keys(platform.schemas)) {
+            if (!platform.schemas[key]) {
+                return;
+            }
+            addPlatformSchema(platform.schemas[key], `${platform.id}/${key}`);
+        }
+    }
+}
+
+async function __loadInit(): Promise<IInitObject> {
+    log("running init routines");
+    const packageJSON = await import("./../../package.json", {
+        with: { type: "json" },
+    });
+    const version = packageJSON.default.version;
+    const platforms = await loadPlatforms(
+        config.get("platforms") as Array<string>,
+    );
+
+    await redisCheck(config.get("redis") as RedisConfig);
+
+    if (config.get("info")) {
+        printSettingsInfo(packageJSON.default.version, platforms);
+    }
+    log("finished init routines");
+    return {
+        version: version,
+        platforms: platforms,
+    };
+}
+
+export function __clearInit() {
+    init = undefined;
+    initCalled = false;
+}

package/src/bootstrap/load-platforms.ts

@@ -0,0 +1,151 @@
+/**
+ * bootstrap/platforms.ts
+ *
+ * A Singleton responsible for finding and loading all valid Sockethub
+ * platforms, and whitelisting or blacklisting (or neither) based on the
+ * config.
+ */
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import debug from "debug";
+
+import {
+    type PlatformConfig,
+    type PlatformInterface,
+    type PlatformSchemaStruct,
+    type PlatformSession,
+    validatePlatformSchema,
+} from "@sockethub/schemas";
+
+const log = debug("sockethub:server:bootstrap:platforms");
+
+export type PlatformStruct = {
+    id: string;
+    moduleName: string;
+    modulePath?: string;
+    config: PlatformConfig;
+    schemas: PlatformSchemaStruct;
+    version: string;
+    types: Array<string>;
+};
+
+export type PlatformMap = Map<string, PlatformStruct>;
+
+const dummySession: PlatformSession = {
+    debug: () => {},
+    sendToClient: () => {},
+    updateActor: async () => {},
+};
+
+// 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): boolean {
+    return (
+        p.schema.messages.properties?.type?.enum &&
+        p.schema.messages.properties.type.enum.length > 0
+    );
+}
+
+// Resolve the absolute filesystem path to a platform module
+function resolveModulePath(platformName: string): string | undefined {
+    try {
+        // Resolve to file:// URL
+        const resolved = import.meta.resolve(platformName);
+
+        // Convert to absolute path
+        const filePath = fileURLToPath(resolved);
+
+        // Walk up to find package.json (package root)
+        let dir = dirname(filePath);
+        for (let i = 0; i < 5; i++) {
+            const pkgPath = join(dir, "package.json");
+            if (existsSync(pkgPath)) {
+                return dir;
+            }
+            dir = dirname(dir);
+        }
+
+        // Fallback: return directory of entry point
+        return dirname(filePath);
+    } catch (err) {
+        log(
+            `failed to resolve module path for ${platformName}: ${err.message}`,
+        );
+        return undefined;
+    }
+}
+
+async function loadPlatform(platformName: string, injectRequire) {
+    log(`loading ${platformName}`);
+    let p: PlatformInterface;
+    if (injectRequire) {
+        const P = await injectRequire(platformName);
+        p = new P();
+    } else {
+        const P = await import(platformName);
+        p = new P.default(dummySession);
+    }
+    const err = validatePlatformSchema(p.schema);
+
+    if (err) {
+        throw new Error(`${platformName} ${err}`);
+    }
+    if (typeof p.config !== "object") {
+        throw new Error(
+            `${platformName} platform must have a config property that is an object.`,
+        );
+    }
+    return p;
+}
+
+export default async function loadPlatforms(
+    platformsList: Array<string>,
+    injectRequire = undefined,
+): Promise<PlatformMap> {
+    log(`platforms to load: ${platformsList}`);
+    // 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 (const platformName of platformsList) {
+        const p = await loadPlatform(platformName, injectRequire);
+        let types = [];
+
+        if (p.schema.credentials) {
+            // register the platforms credentials schema
+            types.push("credentials");
+        } else {
+            p.config.requireCredentials = [];
+        }
+
+        if (platformListsSupportedTypes(p)) {
+            types = [...types, ...p.schema.messages.properties.type.enum];
+        }
+
+        // Resolve module path (skip in test mode with injectRequire)
+        const modulePath = injectRequire
+            ? undefined
+            : resolveModulePath(platformName);
+
+        platforms.set(p.schema.name, {
+            id: p.schema.name,
+            moduleName: p.schema.name,
+            modulePath: modulePath,
+            config: p.config,
+            schemas: {
+                credentials: p.schema.credentials || {},
+                messages: p.schema.messages || {},
+            },
+            version: p.schema.version,
+            types: types,
+        });
+    }
+
+    return platforms;
+}

package/src/config.test.ts

@@ -1,28 +1,33 @@
-import { expect } from 'chai';
+import { describe, expect, it } from "bun:test";
 
-import { Config } from './config';
+import { Config } from "./config.js";
 
-describe('config', () => {
+describe("config", () => {
+    it("loads default values", () => {
+        const config = new Config();
+        expect(config).toHaveProperty("get");
+        expect(config.get("sockethub:host")).toEqual("localhost");
+    });
 
-  it('loads default values', () => {
-    const config = new Config();
-    expect(config).to.have.property('get');
-    expect(config.get('sockethub:host')).to.eql('localhost');
-  });
+    it("host overrides from env", () => {
+        const hostname = "a host string";
+        process.env = { HOST: hostname };
+        const config = new Config();
+        expect(config).toHaveProperty("get");
+        expect(config.get("sockethub:host")).toEqual(hostname);
+    });
 
-  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).toHaveProperty("get");
+        expect(config.get("redis")).toEqual({ url: "redis://127.0.0.1:6379" });
+    });
 
-  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});
-  });
+    // it("redis url overridden by env var", () => {
+    //     process.env = { REDIS_URL: "foobar83" };
+    //     const config = new Config();
+    //     expect(config).toHaveProperty("get");
+    //     expect(config.get("redis")).toEqual({ url: "foobar83" });
+    // });
 });

package/src/config.ts

@@ -1,101 +1,97 @@
-import nconf from 'nconf';
-import { debug } from 'debug';
-import * as fs from "fs";
+import fs from "node:fs";
+import path from "node:path";
+import debug from "debug";
+import nconf from "nconf";
 
-const log = debug('sockethub:server:bootstrap:config');
+import { __dirname } from "./util.js";
 
-export type ActivityStreamConfigOptions = {
-  warnOnUnknownObjectProperties?: boolean;
-  failOnUnknownObjectProperties?: boolean;
-  specialObjs?: object;
-  customProps?: object;
-}
-
-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();
+const log = debug("sockethub:server:bootstrap:config");
+const data = JSON.parse(
+    fs.readFileSync(path.resolve(__dirname, "defaults.json"), "utf-8"),
+);
 
-    // get value of flags defined by any command-line params
-    const examples = nconf.get('examples');
+const defaultConfig = "sockethub.config.json";
 
-    // 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);
+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",
+                type: "string",
+                describe: "Path to sockethub.config.json",
+            },
+            port: {
+                type: "number",
+                alias: "sockethub.port",
+            },
+            host: {
+                type: "string",
+                alias: "sockethub.host",
+            },
+            "redis.url": {
+                type: "string",
+                describe: "Redis URL e.g. redis://host:port",
+            },
+            "sentry.dsn": {
+                type: "string",
+                describe: "Provide your Sentry DSN",
+            },
+        });
 
-    // only override config file if explicitly mentioned in command-line params
-    nconf.set('examples:enabled', (examples ? true : nconf.get('examples:enabled')));
+        // get value of flags defined by any command-line params
+        const examples = nconf.get("examples");
 
-    // load defaults
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const defaults: object = require(__dirname + '/defaults.json');
-    nconf.defaults(defaults);
+        // Load the main config
+        let configFile = nconf.get("config");
+        if (configFile) {
+            configFile = path.resolve(configFile);
+            if (!fs.existsSync(configFile)) {
+                throw new Error(`Config file not found: ${configFile}`);
+            }
+            log(`reading config file at ${configFile}`);
+            nconf.file(configFile);
+        } else {
+            if (fs.existsSync(`${process.cwd()}/${defaultConfig}`)) {
+                log(`loading local ${defaultConfig}`);
+                nconf.file(`${process.cwd()}/${defaultConfig}`);
+            }
+            nconf.use("memory");
+        }
 
-    nconf.required(['platforms']);
+        // only override config file if explicitly mentioned in command-line params
+        nconf.set("examples", examples ? true : nconf.get("examples"));
 
-    function defaultEnvParams(host: string, port: string | number, prop: string) {
-      nconf.set(prop + ':host', host);
-      nconf.set(prop + ':port', port);
-    }
+        // load defaults
+        nconf.defaults(data);
 
-    defaultEnvParams(
-      process.env.HOST || nconf.get('sockethub:host'),
-      process.env.PORT || nconf.get('sockethub:port'),
-      'sockethub'
-    );
+        nconf.required(["platforms"]);
 
-    defaultEnvParams(
-      process.env.REDIS_HOST || nconf.get('redis:host'),
-      process.env.REDIS_PORT || nconf.get('redis:port'),
-      'redis'
-    );
+        nconf.set(
+            "sockethub:host",
+            process.env.HOST || nconf.get("sockethub:host"),
+        );
+        nconf.set(
+            "sockethub:port",
+            process.env.PORT || nconf.get("sockethub:port"),
+        );
 
-    // 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');
+        // allow a redis://user:host:port url, takes precedence
+        if (process.env.REDIS_URL) {
+            nconf.set("redis:url", process.env.REDIS_URL);
+        }
     }
-  }
-  get = (key: string): unknown => nconf.get(key);
+    get = (key: string) => nconf.get(key);
 }
 
 const config = new Config();