@sockethub/server 5.0.0-alpha.11 → 5.0.0-alpha.12

package/src/bootstrap/init.test-helpers.ts

@@ -0,0 +1,75 @@
+import { mock } from "bun:test";
+import type { IInitObject } from "./init.js";
+import { __clearInit } from "./init.js";
+import loadPlatforms from "./load-platforms.js";
+
+function getFakePlatform(name: string) {
+    return class FakeSockethubPlatform {
+        get config() {
+            return {};
+        }
+
+        get schema() {
+            return {
+                name: name,
+                version: "0.0.1",
+                contextUrl: `https://sockethub.org/ns/context/platform/${name}/v1.jsonld`,
+                contextVersion: "1",
+                schemaVersion: "1",
+                credentials: {
+                    required: ["object"],
+                    properties: {
+                        actor: {
+                            type: "object",
+                            required: ["id"],
+                        },
+                        object: {
+                            type: "object",
+                            required: ["type", "user", "pass"],
+                            additionalProperties: false,
+                            properties: {
+                                type: {
+                                    type: "string",
+                                },
+                                user: {
+                                    type: "string",
+                                },
+                                pass: {
+                                    type: "string",
+                                },
+                            },
+                        },
+                    },
+                },
+                messages: {
+                    required: ["type"],
+                    properties: {
+                        type: {
+                            enum: ["echo", "fail"],
+                        },
+                    },
+                },
+            };
+        }
+    };
+}
+
+export async function initMockFakePlatform(platformName: string) {
+    const initObject = {
+        version: "init object",
+        platforms: new Map(),
+    } as IInitObject;
+    __clearInit();
+    const initFunc = async () => {
+        const modules = {};
+        modules[platformName] = getFakePlatform(platformName);
+        initObject.platforms = await loadPlatforms(
+            [platformName],
+            async (module) => {
+                return Promise.resolve(modules[module]);
+            },
+        );
+        return Promise.resolve(initObject);
+    };
+    return mock(initFunc);
+}

package/src/bootstrap/init.test.ts

@@ -1,79 +1,10 @@
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import * as sinon from "sinon";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import getInitObject, {
     __clearInit,
     printSettingsInfo,
     type IInitObject,
 } from "./init.js";
-import loadPlatforms from "./load-platforms.js";
-
-function getFakePlatform(name: string) {
-    return class FakeSockethubPlatform {
-        get config() {
-            return {};
-        }
-
-        get schema() {
-            return {
-                name: name,
-                version: "0.0.1",
-                credentials: {
-                    required: ["object"],
-                    properties: {
-                        actor: {
-                            type: "object",
-                            required: ["id"],
-                        },
-                        object: {
-                            type: "object",
-                            required: ["type", "user", "pass"],
-                            additionalProperties: false,
-                            properties: {
-                                type: {
-                                    type: "string",
-                                },
-                                user: {
-                                    type: "string",
-                                },
-                                pass: {
-                                    type: "string",
-                                },
-                            },
-                        },
-                    },
-                },
-                messages: {
-                    required: ["type"],
-                    properties: {
-                        type: {
-                            enum: ["echo", "fail"],
-                        },
-                    },
-                },
-            };
-        }
-    };
-}
-
-export async function initMockFakePlatform(platformName: string) {
-    const initObject = {
-        version: "init object",
-        platforms: new Map(),
-    } as IInitObject;
-    __clearInit();
-    const initFunc = async () => {
-        const modules = {};
-        modules[platformName] = getFakePlatform(platformName);
-        initObject.platforms = await loadPlatforms(
-            [platformName],
-            async (module) => {
-                return Promise.resolve(modules[module]);
-            },
-        );
-        return Promise.resolve(initObject);
-    };
-    return mock(initFunc);
-}
+import { initMockFakePlatform } from "./init.test-helpers.js";
 
 describe("platformLoad", () => {
     let loadInitMock;
@@ -126,32 +57,50 @@ describe("Init", () => {
 });
 
 describe("printSettingsInfo", () => {
-    let logSpy: sinon.SinonSpy;
-    let exitStub: sinon.SinonStub;
+    let logs: Array<string>;
+    let exitCalled: boolean;
+    let exitMock: () => never;
+    let logMock: (message?: unknown, ...optionalParams: Array<unknown>) => void;
 
     beforeEach(() => {
-        logSpy = sinon.spy(console, "log");
-        exitStub = sinon.stub(process, "exit");
-    });
-
-    afterEach(() => {
-        sinon.restore();
+        logs = [];
+        exitCalled = false;
+        logMock = (message?: unknown, ...optionalParams: Array<unknown>) => {
+            const parts = [message, ...optionalParams].filter(
+                (part) => typeof part !== "undefined",
+            );
+            logs.push(parts.map((part) => String(part)).join(" "));
+        };
+        exitMock = () => {
+            exitCalled = true;
+            throw new Error("exit called");
+        };
     });
 
     it("displays sockethub version", () => {
         const platforms = new Map();
-        printSettingsInfo("5.0.0-alpha.4", platforms);
-
-        // Check for version in output (may have color codes)
-        sinon.assert.calledWithMatch(logSpy, sinon.match(/5\.0\.0-alpha\.4/));
+        expect(() =>
+            printSettingsInfo("5.0.0-alpha.4", platforms, {
+                log: logMock,
+                exit: exitMock,
+            }),
+        ).toThrow("exit called");
+
+        expect(logs.join("\n")).toMatch(/5\.0\.0-alpha\.4/);
     });
 
     it("displays executable path", () => {
         const platforms = new Map();
-        printSettingsInfo("5.0.0", platforms);
-
-        sinon.assert.calledWithMatch(logSpy, sinon.match(/executable:/));
-        sinon.assert.calledWithMatch(logSpy, sinon.match(/sockethub|init/));
+        expect(() =>
+            printSettingsInfo("5.0.0", platforms, {
+                log: logMock,
+                exit: exitMock,
+            }),
+        ).toThrow("exit called");
+
+        const output = logs.join("\n");
+        expect(output).toMatch(/executable:/);
+        expect(output).toMatch(/sockethub|init/);
     });
 
     it("displays platform information with colors", () => {
@@ -166,31 +115,44 @@ describe("printSettingsInfo", () => {
                     types: ["echo", "greet"],
                     config: {},
                     schemas: {
+                        contextUrl:
+                            "https://sockethub.org/ns/context/platform/dummy/v1.jsonld",
+                        contextVersion: "1",
+                        schemaVersion: "1",
                         credentials: {},
                         messages: {},
                     },
+                    contextUrl:
+                        "https://sockethub.org/ns/context/platform/dummy/v1.jsonld",
+                    contextVersion: "1",
+                    schemaVersion: "1",
                 },
             ],
         ]);
 
-        printSettingsInfo("5.0.0", platforms);
-
-        // Verify platform name appears
-        sinon.assert.calledWithMatch(
-            logSpy,
-            sinon.match(/platform-dummy/),
-        );
-        // Verify version appears
-        sinon.assert.calledWithMatch(logSpy, sinon.match(/1\.0\.0/));
-        // Verify path appears
-        sinon.assert.calledWithMatch(logSpy, sinon.match(/path.*dummy/));
+        expect(() =>
+            printSettingsInfo("5.0.0", platforms, {
+                log: logMock,
+                exit: exitMock,
+            }),
+        ).toThrow("exit called");
+
+        const output = logs.join("\n");
+        expect(output).toMatch(/platform-dummy/);
+        expect(output).toMatch(/1\.0\.0/);
+        expect(output).toMatch(/path.*dummy/);
     });
 
     it("calls process.exit after printing", () => {
         const platforms = new Map();
-        printSettingsInfo("5.0.0", platforms);
-
-        sinon.assert.calledOnce(exitStub);
+        expect(() =>
+            printSettingsInfo("5.0.0", platforms, {
+                log: logMock,
+                exit: exitMock,
+            }),
+        ).toThrow("exit called");
+
+        expect(exitCalled).toBeTrue();
     });
 
     it("strips colors in non-TTY environment", () => {
@@ -199,11 +161,13 @@ describe("printSettingsInfo", () => {
         process.env.NO_COLOR = "1";
 
         const platforms = new Map();
-        printSettingsInfo("5.0.0", platforms);
-
-        // Output should not contain ANSI codes
-        const calls = logSpy.getCalls();
-        const output = calls.map((c) => c.args[0]).join("\n");
+        expect(() =>
+            printSettingsInfo("5.0.0", platforms, {
+                log: logMock,
+                exit: exitMock,
+            }),
+        ).toThrow("exit called");
+        const output = logs.join("\n");
         expect(output).not.toMatch(/\x1b\[/); // No ANSI escape codes
 
         process.env.NO_COLOR = oldNoColor;

package/src/bootstrap/init.ts

@@ -1,13 +1,17 @@
 import { fileURLToPath } from "node:url";
-import chalk from "chalk";
-
 import { type RedisConfig, redisCheck } from "@sockethub/data-layer";
-
 import { createLogger } from "@sockethub/logger";
-import { addPlatformSchema } from "@sockethub/schemas";
+import {
+    addPlatformContext,
+    addPlatformSchema,
+    InternalObjectTypesList,
+    setValidationErrorOptions,
+} from "@sockethub/schemas";
+import chalk from "chalk";
 import config from "../config.js";
 import loadPlatforms, {
     type PlatformMap,
+    type PlatformSchemaRegistry,
     type PlatformStruct,
 } from "./load-platforms.js";
 
@@ -18,6 +22,11 @@ export interface IInitObject {
     platforms: PlatformMap;
 }
 
+interface PrintSettingsInfoOptions {
+    log?: (message?: unknown, ...optionalParams: Array<unknown>) => void;
+    exit?: (code?: number) => unknown;
+}
+
 let init: IInitObject;
 
 function getExecutablePath(): string {
@@ -32,51 +41,52 @@ function getExecutablePath(): string {
 export function printSettingsInfo(
     version: string,
     platforms: Map<string, PlatformStruct>,
+    options: PrintSettingsInfoOptions = {},
 ) {
+    const logFn = options.log ?? console.log;
+    const exitFn = options.exit ?? process.exit;
     const execPath = getExecutablePath();
 
-    console.log(`${chalk.cyan("sockethub")} ${version}`);
-    console.log(`${chalk.cyan("executable:")} ${execPath}`);
+    logFn(`${chalk.cyan("sockethub")} ${version}`);
+    logFn(`${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)}`);
+    logFn(`${chalk.cyan("websocket:")} ${chalk.blue(wsUrl)}`);
 
     const examplesUrl = `http://${config.get("public:host")}:${config.get(
         "public:port",
     )}${config.get("public:path")}`;
-    console.log(
+    logFn(
         `${chalk.cyan("examples:")} ${config.get("examples") ? chalk.blue(examplesUrl) : "disabled"}`,
     );
 
-    console.log(
-        `${chalk.cyan("redis URL:")} ${chalk.blue(config.get("redis:url"))}`,
-    );
+    logFn(`${chalk.cyan("redis URL:")} ${chalk.blue(config.get("redis:url"))}`);
 
-    console.log(
+    logFn(
         `${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(
+            logFn();
+            logFn(chalk.green(`- ${platform.moduleName}`));
+            logFn(` ${chalk.dim("version:")} ${platform.version}`);
+            logFn(
                 ` ${chalk.dim("AS types:")} ${platform.types.map((t) => chalk.yellow(t)).join(", ")}`,
             );
             if (platform.modulePath) {
-                console.log(` ${chalk.dim("path:")} ${platform.modulePath}`);
+                logFn(` ${chalk.dim("path:")} ${platform.modulePath}`);
             }
         }
     }
-    console.log();
-    process.exit();
+    logFn();
+    exitFn();
 }
 
 let initCalled = false;
 let initWaitCount = 0;
-let cancelWait: Timer;
-const resolveQueue = [];
+let cancelWait: NodeJS.Timeout | undefined;
+const resolveQueue: Array<(init: IInitObject) => void> = [];
 
 export default async function getInitObject(
     initFunc: () => Promise<IInitObject> = __loadInit,
@@ -108,6 +118,9 @@ export default async function getInitObject(
             if (init) {
                 resolve(init);
             } else {
+                setValidationErrorOptions({
+                    excludeTypes: InternalObjectTypesList,
+                });
                 initFunc()
                     .then((_init) => {
                         init = _init;
@@ -122,12 +135,17 @@ export default async function getInitObject(
 }
 
 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}`);
+    for (const [_platformId, platform] of initObj.platforms) {
+        const schemas: PlatformSchemaRegistry = platform.schemas;
+        addPlatformContext(platform.id, schemas.contextUrl);
+        if (schemas.credentials !== undefined) {
+            addPlatformSchema(
+                schemas.credentials,
+                `${platform.id}/credentials`,
+            );
+        }
+        if (schemas.messages !== undefined) {
+            addPlatformSchema(schemas.messages, `${platform.id}/messages`);
         }
     }
 }

package/src/bootstrap/load-platforms.ts

@@ -13,10 +13,10 @@ import { createLogger } from "@sockethub/logger";
 import {
     type PlatformConfig,
     type PlatformInterface,
-    type PlatformSchemaStruct,
     type PlatformSession,
     validatePlatformSchema,
 } from "@sockethub/schemas";
+import type { Schema } from "ajv";
 
 const log = createLogger("server:bootstrap:platforms");
 
@@ -25,13 +25,26 @@ export type PlatformStruct = {
     moduleName: string;
     modulePath?: string;
     config: PlatformConfig;
-    schemas: PlatformSchemaStruct;
+    schemas: PlatformSchemaRegistry;
     version: string;
+    contextUrl: string;
+    contextVersion: string;
+    schemaVersion: string;
     types: Array<string>;
 };
 
 export type PlatformMap = Map<string, PlatformStruct>;
 
+export type PlatformSchemaRegistry = {
+    name: string;
+    version: string;
+    contextUrl: string;
+    contextVersion: string;
+    schemaVersion: string;
+    credentials?: Schema | boolean;
+    messages?: Schema | boolean;
+};
+
 const dummySession: PlatformSession = {
     log: createLogger("platform:dummy"),
     sendToClient: () => {},
@@ -40,7 +53,7 @@ const dummySession: PlatformSession = {
 
 // 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 {
+function platformListsSupportedTypes(p: PlatformInterface): boolean {
     return (
         p.schema.messages.properties?.type?.enum &&
         p.schema.messages.properties.type.enum.length > 0
@@ -70,13 +83,23 @@ function resolveModulePath(platformName: string): string | undefined {
         return dirname(filePath);
     } catch (err) {
         log.warn(
-            `failed to resolve module path for ${platformName}: ${err.message}`,
+            `failed to resolve module path for ${platformName}: ${
+                err instanceof Error ? err.message : String(err)
+            }`,
         );
         return undefined;
     }
 }
 
-async function loadPlatform(platformName: string, injectRequire) {
+type PlatformConstructor = new (...args: unknown[]) => PlatformInterface;
+type InjectRequire = (
+    moduleName: string,
+) => Promise<PlatformConstructor> | PlatformConstructor;
+
+async function loadPlatform(
+    platformName: string,
+    injectRequire?: InjectRequire,
+) {
     log.debug(`loading ${platformName}`);
     let p: PlatformInterface;
     if (injectRequire) {
@@ -101,11 +124,11 @@ async function loadPlatform(platformName: string, injectRequire) {
 
 export default async function loadPlatforms(
     platformsList: Array<string>,
-    injectRequire = undefined,
+    injectRequire?: InjectRequire,
 ): Promise<PlatformMap> {
     log.debug(`platforms to load: ${platformsList}`);
     // load platforms from config.platforms
-    const platforms = new Map();
+    const platforms = new Map<string, PlatformStruct>();
 
     if (platformsList.length <= 0) {
         throw new Error(
@@ -115,7 +138,7 @@ export default async function loadPlatforms(
 
     for (const platformName of platformsList) {
         const p = await loadPlatform(platformName, injectRequire);
-        let types = [];
+        let types: Array<string> = [];
 
         if (p.schema.credentials) {
             // register the platforms credentials schema
@@ -139,10 +162,18 @@ export default async function loadPlatforms(
             modulePath: modulePath,
             config: p.config,
             schemas: {
+                name: p.schema.name,
+                version: p.schema.version,
+                contextUrl: p.schema.contextUrl,
+                contextVersion: p.schema.contextVersion,
+                schemaVersion: p.schema.schemaVersion,
                 credentials: p.schema.credentials || {},
                 messages: p.schema.messages || {},
             },
             version: p.schema.version,
+            contextUrl: p.schema.contextUrl,
+            contextVersion: p.schema.contextVersion,
+            schemaVersion: p.schema.schemaVersion,
             types: types,
         });
         log.info(`loaded platform ${p.schema.name} v${p.schema.version}`);

package/src/config.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import nconf from "nconf";
 
-import { type Logger, createWinstonLogger } from "./logger-core.js";
+import { createWinstonLogger, type Logger } from "./logger-core.js";
 import { __dirname } from "./util.js";
 
 const data = JSON.parse(
@@ -109,6 +109,17 @@ export class Config {
             "logging:file",
             process.env.LOG_FILE || nconf.get("logging:file"),
         );
+
+        nconf.set(
+            "platformHeartbeat:intervalMs",
+            process.env.SOCKETHUB_PLATFORM_HEARTBEAT_INTERVAL_MS ||
+                nconf.get("platformHeartbeat:intervalMs"),
+        );
+        nconf.set(
+            "platformHeartbeat:timeoutMs",
+            process.env.SOCKETHUB_PLATFORM_HEARTBEAT_TIMEOUT_MS ||
+                nconf.get("platformHeartbeat:timeoutMs"),
+        );
     }
     get = (key: string) => nconf.get(key);
 }

package/src/defaults.json

@@ -44,5 +44,9 @@
     "port": 10550,
     "host": "localhost",
     "path": "/sockethub"
+  },
+  "platformHeartbeat": {
+    "intervalMs": 5000,
+    "timeoutMs": 15000
   }
 }

package/src/index.ts

@@ -4,7 +4,7 @@ import config from "./config";
 import Sockethub from "./sockethub";
 
 let sentry: { readonly reportError: (err: Error) => void } = {
-    reportError: (err: Error) => {},
+    reportError: (_err: Error) => {},
 };
 
 export async function server() {
@@ -34,8 +34,9 @@ export async function server() {
     try {
         sockethub = new Sockethub();
     } catch (err) {
-        sentry.reportError(err);
-        console.error(err);
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry.reportError(error);
+        console.error(error);
         process.exit(1);
     }
 
@@ -48,12 +49,12 @@ export async function server() {
         process.exit(1);
     });
 
-    process.once("unhandledRejection", (err: Error) => {
+    process.once("unhandledRejection", (err: unknown) => {
         console.error(
             `${(new Date()).toUTCString()} UNHANDLED REJECTION\n`,
             err,
         );
-        sentry.reportError(err);
+        sentry.reportError(err instanceof Error ? err : new Error(String(err)));
         process.exit(1);
     });
 
@@ -76,8 +77,9 @@ export async function server() {
     try {
         await sockethub.boot();
     } catch (err) {
-        sentry.reportError(err);
-        console.error(err);
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry.reportError(error);
+        console.error(error);
         process.exit(1);
     }
 }

package/src/janitor.ts

@@ -44,7 +44,9 @@ export class Janitor {
         platformInstance: PlatformInstance,
         sessionId: string,
     ): void {
-        for (const key in platformInstance.sessionCallbacks) {
+        for (const key of Object.keys(
+            platformInstance.sessionCallbacks,
+        ) as Array<"close" | "message">) {
             platformInstance.process.removeListener(
                 key,
                 platformInstance.sessionCallbacks[key].get(sessionId),