socket-function 0.8.35 → 0.8.36

package/SocketFunction.ts

@@ -1,10 +1,14 @@
+/// <reference path="./require/RequireController.ts" />
+
 import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType } from "./SocketFunctionTypes";
 import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
 import { SocketServerConfig, startSocketServer } from "./src/webSocketServer";
 import { getCreateCallFactoryLocation, getNodeId, getNodeIdLocation } from "./src/nodeCache";
 import { getCallProxy } from "./src/nodeProxy";
-import { Args } from "./src/types";
+import { Args, MaybePromise } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
+import debugbreak from "debugbreak";
+import { lazy } from "./src/caching";
 
 module.allowclient = true;
 
@@ -29,6 +33,11 @@ export class SocketFunction {
     };
     public static httpETagCache = false;
 
+    private static onMountCallbacks = new Map<string, (() => MaybePromise<void>)[]>();
+    public static exposedClasses = new Set<string>();
+
+    // NOTE: We use callbacks we don't run into issues with cyclic dependencies
+    //  (ex, using a hook in a controller where the hook also calls the controller).
     public static register<
         ClassInstance extends object,
         Shape extends SocketExposedShape<SocketExposedInterface, CallContext>,
@@ -36,20 +45,28 @@ export class SocketFunction {
     >(
         classGuid: string,
         instance: ClassInstance,
-        shape: Shape,
-        defaultHooks?: SocketExposedShape[""]
-    ):
-        (
-            SocketRegistered<ExtractShape<ClassInstance, Shape>, CallContext>
-        ) {
-
-        for (let value of Object.values(shape)) {
-            if (!value) continue;
-            value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];
-            value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];
-            value.dataImmutable = defaultHooks?.dataImmutable ?? value.dataImmutable;
+        shapeFnc: () => Shape,
+        defaultHooksFnc?: () => SocketExposedShape[""] & {
+            onMount?: () => MaybePromise<void>;
         }
-        registerClass(classGuid, instance as SocketExposedInterface, shape as any as SocketExposedShape);
+    ): SocketRegistered<ExtractShape<ClassInstance, Shape>, CallContext> {
+        let getDefaultHooks = defaultHooksFnc && lazy(defaultHooksFnc);
+        const getShape = lazy(() => {
+            let shape = shapeFnc();
+            let defaultHooks = getDefaultHooks?.();
+
+            for (let value of Object.values(shape)) {
+                if (!value) continue;
+                value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];
+                value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];
+                value.dataImmutable = defaultHooks?.dataImmutable ?? value.dataImmutable;
+            }
+            return shape as any as SocketExposedShape;
+        });
+
+        setImmediate(() => {
+            registerClass(classGuid, instance as SocketExposedInterface, getShape());
+        });
 
         let nodeProxy = getCallProxy(classGuid, async (call) => {
             let nodeId = call.nodeId;
@@ -61,7 +78,7 @@ export class SocketFunction {
             try {
                 let callFactory = await getCreateCallFactoryLocation(nodeId, SocketFunction.mountedNodeId);
 
-                let shapeObj = shape[functionName];
+                let shapeObj = getShape()[functionName];
                 if (!shapeObj) {
                     throw new Error(`Function ${functionName} is not in shape`);
                 }
@@ -72,20 +89,6 @@ export class SocketFunction {
                     return hookResult.overrideResult;
                 }
 
-                if (hookResult.callTimeout !== undefined) {
-                    let timeout = hookResult.callTimeout;
-                    let time = Date.now();
-                    let timeoutPromise = new Promise((resolve, reject) => {
-                        setTimeout(() => {
-                            reject(new Error(`Call timed out after ${Date.now() - time}ms`));
-                        }, timeout);
-                    });
-                    return await Promise.race([
-                        callFactory.performCall(call),
-                        timeoutPromise,
-                    ]);
-                }
-
                 return await callFactory.performCall(call);
             } finally {
                 time = Date.now() - time;
@@ -101,6 +104,18 @@ export class SocketFunction {
             _classGuid: classGuid,
         };
 
+        setImmediate(() => {
+            let onMount = getDefaultHooks?.().onMount;
+            if (onMount) {
+                let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
+                if (!callbacks) {
+                    callbacks = [];
+                    SocketFunction.onMountCallbacks.set(classGuid, callbacks);
+                }
+                callbacks.push(onMount);
+            }
+        });
+
         return output as any;
     }
 
@@ -125,15 +140,33 @@ export class SocketFunction {
      */
     public static expose(socketRegistered: SocketRegistered) {
         exposeClass(socketRegistered);
+        SocketFunction.exposedClasses.add(socketRegistered._classGuid);
+
+        if (this.hasMounted) {
+            let mountCallbacks = SocketFunction.onMountCallbacks.get(socketRegistered._classGuid);
+            for (let onMount of mountCallbacks || []) {
+                Promise.resolve(onMount()).catch(e => {
+                    console.error("Error in onMount callback exposed after mount", e);
+                });
+            }
+        }
     }
 
     public static mountedNodeId: string = "NOTMOUNTED";
-    public static async mount(config: SocketServerConfig & { nodeId: string }) {
+    private static hasMounted = false;
+    public static async mount(config: SocketServerConfig) {
         if (this.mountedNodeId !== "NOTMOUNTED") {
             throw new Error("SocketFunction already mounted, mounting twice in one thread is not allowed.");
         }
-        this.mountedNodeId = config.nodeId;
-        await startSocketServer(config);
+        this.mountedNodeId = await startSocketServer(config);
+        this.hasMounted = true;
+        for (let classGuid of SocketFunction.exposedClasses) {
+            let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
+            if (!callbacks) continue;
+            for (let callback of callbacks) {
+                await callback();
+            }
+        }
         return this.mountedNodeId;
     }
 

package/SocketFunctionTypes.ts

@@ -1,3 +1,5 @@
+/// <reference path="./require/RequireController.ts" />
+
 module.allowclient = true;
 
 import { getCallObj } from "./src/nodeProxy";
@@ -34,9 +36,6 @@ export interface CallType {
     classGuid: string;
     functionName: string;
     args: unknown[];
-    // NOTE: When making calls this needs to be set in the client hook.
-    //  To set a timeout on returns, you can set it in the server hook.
-    reconnectTimeout?: number;
 }
 export interface FullCallType extends CallType {
     nodeId: string;
@@ -44,6 +43,8 @@ export interface FullCallType extends CallType {
 
 export interface SocketFunctionHook<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
     (config: HookContext<ExposedType, CallContext>): MaybePromise<void>;
+    /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
+    clientHook?: SocketFunctionClientHook<ExposedType, CallContext>;
 }
 export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
     call: FullCallType;
@@ -54,10 +55,6 @@ export type HookContext<ExposedType extends SocketExposedInterface = SocketExpos
 
 export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
     call: FullCallType;
-    /** If the calls takes longer than this (for ANY reason), we return with an error.
-     *      - Different from reconnectTimeout, which only errors if we lose the connection.
-    */
-    callTimeout?: number;
     // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
     overrideResult?: unknown;
 };

package/hot/HotReloadController.ts

@@ -64,8 +64,8 @@ class HotReloadControllerBase {
 export const HotReloadController = SocketFunction.register(
     "HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5",
     new HotReloadControllerBase(),
-    {
+    () => ({
         watchFiles: {},
         fileUpdated: {}
-    }
+    })
 );

package/package.json

@@ -1,14 +1,10 @@
 {
 	"name": "socket-function",
-	"version": "0.8.35",
+	"version": "0.8.36",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
 	"dependencies": {
-		"@types/cookie": "^0.5.1",
-		"@types/node": "^18.0.0",
-		"@types/node-forge": "^1.3.1",
-		"@types/ws": "^8.5.3",
 		"cookie": "^0.5.0",
 		"mobx": "^6.6.2",
 		"node-forge": "https://github.com/sliftist/forge#name",
@@ -21,7 +17,10 @@
 		"type": "yarn tsc --noEmit"
 	},
 	"devDependencies": {
+		"@types/cookie": "^0.5.1",
+		"@types/node-forge": "^1.3.1",
+		"@types/ws": "^8.5.3",
 		"debugbreak": "^0.6.5",
-		"typedev": "^0.1.0"
+		"typedev": "^0.1.1"
 	}
 }

package/require/CSSShim.ts

@@ -1,3 +1,4 @@
+/// <reference path=".//RequireController.ts" />
 import debugbreak from "debugbreak";
 import { compileTransformBefore } from "typenode";
 

package/require/RequireController.ts

@@ -1,3 +1,4 @@
+/// <reference path="../../typenode/index.d.ts" />
 import debugbreak from "debugbreak";
 import fs from "fs";
 import { SocketFunction } from "../SocketFunction";
@@ -9,7 +10,7 @@ module.allowclient = true;
 declare global {
     namespace NodeJS {
         interface Module {
-            /** Indiciates the module is allowed clientside. */
+            /** Indicates the module is allowed clientside. */
             allowclient?: boolean;
 
             /** Indicates the module is definitely not allowed clientside */
@@ -237,10 +238,10 @@ export function setRequireBootRequire(path: string) {
 export const RequireController = SocketFunction.register(
     "RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d",
     baseController,
-    {
+    () => ({
         getModules: {},
         requireHTML: {},
         bufferJS: {},
         requireJS: {},
-    }
+    })
 );

package/require/compileFlags.ts

@@ -1,3 +1,4 @@
+/// <reference path="./RequireController.ts" />
 module.allowclient = true;
 
 /**

package/src/CallFactory.ts

@@ -2,13 +2,13 @@ import { CallerContext, CallerContextBase, CallType, FullCallType } from "../Soc
 import * as ws from "ws";
 import { performLocalCall } from "./callManager";
 import { convertErrorStackToError, formatNumberSuffixed, isNode } from "./misc";
-import { createWebsocketFactory, getTLSSocket } from "./nodeAuthentication";
+import { createWebsocketFactory, getTLSSocket } from "./websocketFactory";
 import { SocketFunction } from "../SocketFunction";
 import { gzip } from "zlib";
 import * as tls from "tls";
 import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCache";
-
-const retryInterval = 2000;
+import debugbreak from "debugbreak";
+import { lazy } from "./caching";
 
 type InternalCallType = FullCallType & {
     seqNum: number;
@@ -45,6 +45,8 @@ export interface SenderInterface {
     addEventListener(event: "close", listener: () => void): void;
     addEventListener(event: "error", listener: (err: { message: string }) => void): void;
     addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
+
+    readyState: number;
 }
 
 export async function createCallFactory(
@@ -55,19 +57,13 @@ export async function createCallFactory(
     let niceConnectionName = nodeId;
 
     const createWebsocket = createWebsocketFactory();
-
-    let retriesEnabled = !!getNodeIdLocation(nodeId);
+    const registerOnce = lazy(() => registerNodeClient(callFactory));
 
     let lastReceivedSeqNum = 0;
 
-    let reconnectingPromise: Promise<void> | undefined;
-    let reconnectAttempts = 0;
-
-
     let pendingCalls: Map<number, {
         data: Buffer;
         call: InternalCallType;
-        reconnectTimeout: number | undefined;
         callback: (resultJSON: InternalReturnType) => void;
     }> = new Map();
     // NOTE: It is important to make this as random as possible, to prevent
@@ -111,144 +107,78 @@ export async function createCallFactory(
                         resolve(result.result);
                     }
                 };
-                pendingCalls.set(seqNum, { callback, data, call: fullCall, reconnectTimeout: call.reconnectTimeout });
+                pendingCalls.set(seqNum, { callback, data, call: fullCall });
             });
 
-            await sendWithRetry(call.reconnectTimeout, data);
+            await send(data);
 
             return await resultPromise;
         }
     };
 
-    let webSocket!: SenderInterface;
-    if (!webSocketBase) {
-        await tryToReconnect();
-    } else {
-        webSocket = webSocketBase;
-        setupWebsocket(webSocketBase);
+    let webSocketPromise: Promise<SenderInterface> | undefined;
+    if (webSocketBase) {
+        webSocketPromise = Promise.resolve(webSocketBase);
+        await initializeWebsocket(webSocketBase);
     }
 
-    niceConnectionName = `${niceConnectionName} (${callerContext.nodeId})`;
-
-    async function sendWithRetry(reconnectTimeout: number | undefined, data: Buffer) {
-        if (!retriesEnabled) {
-            webSocket.send(data);
-            return;
-        }
-
-        while (true) {
-            if (reconnectingPromise) {
-                if (reconnectTimeout) {
-                    await Promise.race([
-                        reconnectingPromise,
-                        new Promise<SenderInterface>(resolve =>
-                            setTimeout(() => {
-                                retriesEnabled = false;
-                                resolve(webSocket);
-                            }, reconnectTimeout)
-                        )
-                    ]);
-                } else {
-                    await reconnectingPromise;
-                }
-            }
-
-            if (!retriesEnabled) {
-                webSocket.send(data);
-                break;
-            }
-
-            try {
-                webSocket.send(data);
-                break;
-            } catch (e) {
-                // Ignore errors, as we will catch them synchronously in the next loop.
-                void (tryToReconnect());
+    async function initializeWebsocket(newWebSocket: SenderInterface) {
+        registerOnce();
+
+        function onClose(error: string) {
+            webSocketPromise = undefined;
+            for (let [key, call] of pendingCalls) {
+                pendingCalls.delete(key);
+                call.callback({
+                    isReturn: true,
+                    result: undefined,
+                    error: error,
+                    seqNum: call.call.seqNum,
+                    resultSize: 0,
+                    compressed: false,
+                });
             }
         }
-    }
-    function tryToReconnect(): Promise<void> {
-        if (reconnectingPromise) return reconnectingPromise;
-        return reconnectingPromise = (async () => {
-            while (true) {
-                if (!retriesEnabled) {
-                    callFactory.closedForever = true;
-                    console.log(`Cannot reconnect to ${niceConnectionName}, aborting pendingCalls: ${pendingCalls.size}`);
-                    for (let call of pendingCalls.values()) {
-                        call.callback({
-                            isReturn: true,
-                            result: undefined,
-                            error: `Connection lost to ${niceConnectionName}`,
-                            seqNum: call.call.seqNum,
-                            resultSize: 0,
-                            compressed: false,
-                        });
-                    }
-                    return;
-                }
-
-                let newWebSocket = createWebsocket(nodeId);
-
-                let connectError = await new Promise<string | undefined>(resolve => {
-                    newWebSocket.addEventListener("open", () => {
-                        resolve(undefined);
-                    });
-                    newWebSocket.addEventListener("close", () => {
-                        resolve("Connection closed for non-error reason?");
-                    });
-                    newWebSocket.addEventListener("error", e => {
-                        resolve(String(e.message));
-                    });
-                });
-
-                setupWebsocket(newWebSocket);
 
-                if (!connectError) {
-                    console.log(`Reconnected to ${niceConnectionName}`);
+        newWebSocket.addEventListener("error", e => {
+            // NOTE: No more logging, as we throw, so the caller should be logging the
+            //  error (or swallowing it, if that is what it wants to do).
+            //console.log(`Websocket error for ${niceConnectionName}`, e.message);
+            onClose(`Connection error for ${niceConnectionName}: ${e.message}`);
+        });
 
-                    // I'm not sure if we should clear reconnectAttempts? Maybe if we eventually have a max reconnectAttempts?
-                    //reconnectAttempts = 0;
-                    reconnectingPromise = undefined;
+        newWebSocket.addEventListener("close", async () => {
+            //console.log(`Websocket closed ${niceConnectionName}`);
+            onClose(`Connection closed to ${niceConnectionName}`);
+        });
 
-                    webSocket = newWebSocket;
+        newWebSocket.addEventListener("message", onMessage);
 
-                    for (let call of pendingCalls.values()) {
-                        sendWithRetry(call.reconnectTimeout, call.data).catch(e => {
-                            call.callback({
-                                isReturn: true,
-                                result: undefined,
-                                error: String(e),
-                                seqNum: call.call.seqNum,
-                                resultSize: 0,
-                                compressed: false,
-                            });
-                        });
-                    }
-                    return;
-                }
 
-                reconnectAttempts++;
-                console.error(`Connection retry to ${niceConnectionName} failed (attempt ${reconnectAttempts}), retrying in ${retryInterval}ms, error: ${JSON.stringify(connectError)}`);
-                await new Promise(resolve => setTimeout(resolve, retryInterval));
-            }
-        })();
+        if (newWebSocket.readyState === 0 /* CONNECTING */) {
+            await new Promise<void>(resolve => {
+                newWebSocket.addEventListener("open", () => {
+                    console.log(`Connection established to ${niceConnectionName}`);
+                    resolve();
+                });
+                newWebSocket.addEventListener("close", () => resolve());
+                newWebSocket.addEventListener("error", () => resolve());
+            });
+        } else if (newWebSocket.readyState !== 1 /* OPEN */) {
+            onClose(`Websocket received in closed state`);
+        }
     }
 
-    function setupWebsocket(webSocket: SenderInterface) {
-        registerNodeClient(callFactory);
-
-        webSocket.addEventListener("error", e => {
-            console.log(`Websocket error for ${niceConnectionName}`, e);
-        });
-
-        webSocket.addEventListener("close", async () => {
-            console.log(`Websocket closed ${niceConnectionName}`);
-            if (retriesEnabled) {
-                await tryToReconnect();
-            }
-        });
+    async function send(data: Buffer) {
+        webSocketPromise = webSocketPromise || tryToReconnect();
+        let webSocket = await webSocketPromise;
+        webSocket.send(data);
+    }
+    async function tryToReconnect(): Promise<SenderInterface> {
+        let newWebSocket = createWebsocket(nodeId);
+        await initializeWebsocket(newWebSocket);
 
-        webSocket.addEventListener("message", onMessage);
+        return newWebSocket;
     }
 
 
@@ -328,7 +258,7 @@ export async function createCallFactory(
                     } else {
                         result = Buffer.from(JSON.stringify(response));
                     }
-                    await sendWithRetry(call.reconnectTimeout, result);
+                    await send(result);
                 }
                 return;
             }

package/src/caching.ts

@@ -33,6 +33,7 @@ export function cacheEmptyArray<T>(array: T[]): T[] {
 
 export function cache<Output, Key>(getValue: (key: Key) => Output): {
     (key: Key): Output;
+    clear(key: Key): void;
 } {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
@@ -51,6 +52,9 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
         values.set(key, value);
         return value;
     }
+    cache.clear = (key: Key) => {
+        values.delete(key);
+    };
     return cache;
 }
 

package/src/callManager.ts

@@ -1,5 +1,7 @@
 import { CallContextType, CallerContext, CallType, ClientHookContext, FullCallType, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 import { _setSocketContext } from "../SocketFunction";
+import { isNode } from "./misc";
+import debugbreak from "debugbreak";
 
 let classes: {
     [classGuid: string]: {
@@ -96,7 +98,17 @@ export async function runClientHooks(
     hooks: SocketExposedShape[""],
 ): Promise<ClientHookContext> {
     let context: ClientHookContext = { call: callType };
-    for (let hook of globalClientHooks.concat(hooks.clientHooks || [])) {
+
+    let clientHooks = (
+        globalClientHooks
+            .concat(hooks.clientHooks || [])
+    );
+    for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {
+        if (otherClientHook) {
+            clientHooks.push(otherClientHook);
+        }
+    }
+    for (let hook of clientHooks) {
         await hook(context);
         if ("overrideResult" in context) {
             break;

package/src/misc.ts

@@ -1,4 +1,7 @@
 import * as crypto from "crypto";
+import { MaybePromise } from "./types";
+
+export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
 
 export function convertErrorStackToError(error: string): Error {
     let errorObj = new Error();

package/src/nodeCache.ts

@@ -19,11 +19,21 @@ export function getNodeId(domain: string, port: number): string {
 
 /** A nodeId not available for reconnecting. */
 export function getClientNodeId(address: string): string {
-    return `client_${address}:${Date.now()}:${Math.random()}`;
+    return `client:${address}:${Date.now()}:${Math.random()}`;
+}
+/** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
+ *      but we should always have an address).
+ *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
+ *  */
+export function getNodeIdIP(nodeId: string): string {
+    if (nodeId.startsWith("client:")) {
+        return nodeId.split(":")[1];
+    }
+    return getNodeIdLocation(nodeId)!.address;
 }
 
 export function getNodeIdLocation(nodeId: string): { address: string, port: number; } | undefined {
-    if (nodeId.startsWith("client_")) {
+    if (nodeId.startsWith("client:")) {
         return undefined;
     }
     let [address, port] = nodeId.split(":");

package/src/webSocketServer.ts

@@ -9,15 +9,18 @@ import { getTrustedCertificates, watchTrustedCertificates } from "./certStore";
 import { createCallFactory } from "./CallFactory";
 import { parseSNIExtension, parseTLSHello, SNIType } from "./tlsParsing";
 import debugbreak from "debugbreak";
+import { getNodeId } from "./nodeCache";
+import crypto from "crypto";
+import { Watchable } from "./misc";
 
 export type SocketServerConfig = (
     https.ServerOptions & {
-        nodeId?: string;
-
         key: string | Buffer;
         cert: string | Buffer;
 
         port: number;
+        /** You can also set `port: 0` if you don't care what port you want at all.  */
+        useAvailablePortIfPortInUse?: boolean;
 
         // public sets ip to "0.0.0.0", otherwise it defaults to "127.0.0.1", which
         //  causes the server to only accept local connections.
@@ -26,24 +29,38 @@ export type SocketServerConfig = (
 
         /** If the SNI matches this domain, we use a different key/cert. */
         SNICerts?: {
-            [domain: string]: https.ServerOptions;
+            [domain: string]: Watchable<https.ServerOptions>;
         };
     }
 );
 
 export async function startSocketServer(
     config: SocketServerConfig
-): Promise<void> {
+): Promise<string> {
 
     const webSocketServer = new ws.Server({
         noServer: true,
     });
 
-    function setupHTTPSServer(options: https.ServerOptions) {
-        let httpsServer = https.createServer(options);
+    async function setupHTTPSServer(watchOptions: Watchable<https.ServerOptions>) {
+        let httpsServerLast: https.Server | undefined;
+        let onHttpServer: (server: https.Server) => void;
+        let httpServerPromise = new Promise<https.Server>(r => onHttpServer = r);
+        let lastOptions!: https.ServerOptions;
+        await watchOptions(value => {
+            lastOptions = { ...value, ca: getTrustedCertificates() };
+            if (!httpsServerLast) {
+                httpsServerLast = https.createServer(lastOptions);
+            } else {
+                httpsServerLast.setSecureContext(lastOptions);
+            }
+            onHttpServer(httpsServerLast);
+        });
+        let httpsServer = await httpServerPromise;
+
         watchTrustedCertificates(() => {
-            options.ca = getTrustedCertificates();
-            httpsServer.setSecureContext(options);
+            lastOptions.ca = getTrustedCertificates();
+            httpsServer.setSecureContext(lastOptions);
         });
 
         httpsServer.on("connection", socket => {
@@ -97,11 +114,17 @@ export async function startSocketServer(
     let options: https.ServerOptions = {
         ...config,
     };
+    if (!config.cert) {
+        throw new Error("No cert specified");
+    }
+    if (!config.key) {
+        throw new Error("No key specified");
+    }
 
-    const mainHTTPSServer = setupHTTPSServer(options);
+    const mainHTTPSServer = await setupHTTPSServer(callback => callback(options));
     let sniServers = new Map<string, https.Server>();
     for (let [domain, obj] of Object.entries(config.SNICerts || {})) {
-        sniServers.set(domain, setupHTTPSServer(obj));
+        sniServers.set(domain, await setupHTTPSServer(obj));
     }
 
     let httpServer = http.createServer({}, async function (req, res) {
@@ -130,6 +153,7 @@ export async function startSocketServer(
             } else {
                 let data = parseTLSHello(buffer);
                 let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];
+                console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}`);
                 server = sniServers.get(sni) || mainHTTPSServer;
             }
 
@@ -158,12 +182,43 @@ export async function startSocketServer(
         host = "0.0.0.0";
     }
 
-    console.log(`Trying to listening on ${host}:${config.port}`);
-    realServer.listen(config.port, host);
+    let port = config.port;
+    if (config.useAvailablePortIfPortInUse && port) {
+        async function isPortInUse(port: number): Promise<boolean> {
+            return new Promise<boolean>((resolve, reject) => {
+                let server = net.createServer();
+                server.listen(port, host)
+                    .on("listening", function () {
+                        server.close();
+                        resolve(false);
+                    }).on("close", function () {
+                        resolve(true);
+                    }).on("error", function (e) {
+                        resolve(true);
+                    });
+            });
+        }
+        if (await isPortInUse(port)) {
+            port = 0;
+        }
+    }
+
+    console.log(`Trying to listening on ${host}:${port}`);
+    realServer.listen(port, host);
 
     await listenPromise;
 
-    let port = (realServer.address() as net.AddressInfo).port;
+    port = (realServer.address() as net.AddressInfo).port;
+    let nodeId = getNodeId(getCommonName(config.cert), port);
+    console.log(`Started Listening on ${nodeId}`);
+
+    return nodeId;
+}
 
-    console.log(`Started Listening on ${config.nodeId || host}:${port}`);
+function getCommonName(cert: Buffer | string) {
+    let subject = new crypto.X509Certificate(cert).subject;
+    let subjectKVPs = new Map(subject.split(",").map(x => x.trim().split("=")).map(x => [x[0], x.slice(1).join("=")]));
+    let commonName = subjectKVPs.get("CN");
+    if (!commonName) throw new Error(`No common name in subject: ${subject}`);
+    return commonName;
 }

package/src/{nodeAuthentication.ts → websocketFactory.ts}

@@ -4,6 +4,7 @@ import { isNode } from "./misc";
 import { SenderInterface } from "./CallFactory";
 import { getTrustedCertificates } from "./certStore";
 import { getNodeIdLocation } from "./nodeCache";
+import debugbreak from "debugbreak";
 
 
 export function getTLSSocket(webSocket: ws.WebSocket) {

package/test/client.ts

@@ -1,3 +1,5 @@
+/// <reference path="../require/RequireController.ts" />
+
 // https://letx.ca:2542/?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=requireHTML&args=[%22./test/test%22]
 
 //import typescript from "typescript";
@@ -24,8 +26,6 @@ void main();
 async function main() {
     if (isNode()) return;
 
-    SocketFunction.rejectUnauthorized = false;
-
     SocketFunction.expose(Test);
 
     console.log("cool");

package/test/shared.ts

@@ -41,7 +41,7 @@ class TestBase {
 export const Test = SocketFunction.register(
     "80d9f328-72df-4baa-8be8-019c1003d4a2",
     new TestBase(),
-    {
+    () => ({
         add: {
             // hooks: [
             //     async (config) => {
@@ -49,17 +49,11 @@ export const Test = SocketFunction.register(
             //     }
             // ]
         },
-        callMe: {
-            clientHooks: [
-                async (config) => {
-                    config.call.reconnectTimeout = 2000;
-                }
-            ]
-        },
+        callMe: {},
         callBack: {
 
         },
         //fncNotAsync: {},
         //notAFnc: {},
-    }
+    })
 );