socket-function 0.8.34 → 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;
 
@@ -28,8 +32,12 @@ export class SocketFunction {
         type: "gzip";
     };
     public static httpETagCache = false;
-    public static rejectUnauthorized = true;
 
+    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>,
@@ -37,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;
@@ -62,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`);
                 }
@@ -73,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;
@@ -102,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;
     }
 
@@ -126,14 +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";
+    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 = 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,11 +1,7 @@
+/// <reference path="./require/RequireController.ts" />
+
 module.allowclient = true;
 
-import debugbreak from "debugbreak";
-import * as tls from "tls";
-import { SenderInterface } from "./src/CallFactory";
-import { isNode } from "./src/misc";
-import { CertInfo, getNodeIdFromCert } from "./src/nodeAuthentication";
-import { getClientNodeId } from "./src/nodeCache";
 import { getCallObj } from "./src/nodeProxy";
 import { Args, MaybePromise } from "./src/types";
 
@@ -40,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;
@@ -50,20 +43,18 @@ 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: CallType;
+    call: FullCallType;
     context: SocketRegistered<ExposedType, CallContext>["context"];
     // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
     overrideResult?: unknown;
 };
 
 export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
-    call: CallType;
-    /** 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;
+    call: FullCallType;
     // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
     overrideResult?: unknown;
 };
@@ -101,15 +92,6 @@ export type CallerContextBase = {
     //      a more permanent identity, you must derive it from certInfo yourself.
     nodeId: string;
 
-    /** Gives further info on the node. When we set this, we always make sure it has a verified
-     *      issuer. It may be set by app code, which should make sure the issuer is verified (not
-     *      necessarily by the machine, but just in some sense, 'verified', to secure the common name
-     *      of the cert and prevent anyone from using the same common name as someone else).
-     *  IF set, is directly used to derive nodeId (by nodeAuthentication.ts)
-     */
-    certInfo: CertInfo | undefined;
-    updateCertInfo?: (certInfo: CertInfo, callbackPort: number | undefined) => void;
-
     // The nodeId they contacted. This is useful to determine their intention (otherwise
     //  requests can be redirected to us and would accept them, even though they are being
     //  blatantly MITMed).

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,16 +1,11 @@
 {
 	"name": "socket-function",
-	"version": "0.8.34",
+	"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",
-		"debugbreak": "^0.6.5",
 		"mobx": "^6.6.2",
 		"node-forge": "https://github.com/sliftist/forge#name",
 		"preact": "^10.10.6",
@@ -22,6 +17,10 @@
 		"type": "yarn tsc --noEmit"
 	},
 	"devDependencies": {
-		"typedev": "^0.1.0"
+		"@types/cookie": "^0.5.1",
+		"@types/node-forge": "^1.3.1",
+		"@types/ws": "^8.5.3",
+		"debugbreak": "^0.6.5",
+		"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

@@ -1,16 +1,16 @@
-import { CallerContext, CallerContextBase, CallType } from "../SocketFunctionTypes";
+import { CallerContext, CallerContextBase, CallType, FullCallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
 import { performLocalCall } from "./callManager";
 import { convertErrorStackToError, formatNumberSuffixed, isNode } from "./misc";
-import { createWebsocketFactory, getNodeIdFromCert, 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";
+import debugbreak from "debugbreak";
+import { lazy } from "./caching";
 
-const retryInterval = 2000;
-
-type InternalCallType = CallType & {
+type InternalCallType = FullCallType & {
     seqNum: number;
     isReturn: false;
     compress: boolean;
@@ -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
@@ -77,16 +73,7 @@ export async function createCallFactory(
 
     let callerContext: CallerContextBase = {
         nodeId,
-        localNodeId,
-        certInfo: webSocketBase?.socket?.getPeerCertificate(true),
-        updateCertInfo: (certRaw, port) => {
-            let nodeId = getNodeIdFromCert(certRaw, port);
-            if (!nodeId) {
-                return;
-            }
-            callerContext.nodeId = nodeId;
-            callerContext.certInfo = certRaw;
-        }
+        localNodeId
     };
 
     let callFactory: CallFactory = {
@@ -99,6 +86,7 @@ export async function createCallFactory(
 
             let seqNum = nextSeqNum++;
             let fullCall: InternalCallType = {
+                nodeId,
                 isReturn: false,
                 args: call.args,
                 classGuid: call.classGuid,
@@ -119,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;
     }
 
 
@@ -336,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/callHTTPHandler.ts

@@ -1,6 +1,6 @@
 import http from "http";
 import tls from "tls";
-import { CallerContext, CallType } from "../SocketFunctionTypes";
+import { CallerContext, CallType, FullCallType } from "../SocketFunctionTypes";
 import { isDataImmutable, performLocalCall } from "./callManager";
 import { SocketFunction } from "../SocketFunction";
 import { gzip } from "zlib";
@@ -79,7 +79,6 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
 
         let caller: CallerContext = {
             nodeId,
-            certInfo: undefined,
             localNodeId,
         };
 
@@ -112,7 +111,8 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
             args = JSON.parse(payload.toString())["args"] as unknown[];
         }
 
-        let call: CallType = {
+        let call: FullCallType = {
+            nodeId,
             classGuid,
             functionName,
             args,

package/src/callManager.ts

@@ -1,5 +1,7 @@
-import { CallContextType, CallerContext, CallType, ClientHookContext, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+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]: {
@@ -14,7 +16,7 @@ let globalClientHooks: SocketFunctionClientHook[] = [];
 
 export async function performLocalCall(
     config: {
-        call: CallType;
+        call: FullCallType;
         caller: CallerContext;
     }
 ): Promise<unknown> {
@@ -92,11 +94,21 @@ export function unregisterGlobalClientHook(hook: SocketFunctionClientHook) {
 }
 
 export async function runClientHooks(
-    callType: CallType,
+    callType: FullCallType,
     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;
@@ -106,7 +118,7 @@ export async function runClientHooks(
 }
 
 async function runServerHooks(
-    callType: CallType,
+    callType: FullCallType,
     context: SocketRegistered["context"],
     hooks: SocketExposedShape[""],
 ): Promise<HookContext> {

package/src/certStore.ts

@@ -1,50 +1,24 @@
-import * as os from "os";
-import * as fs from "fs/promises";
-import * as fsSync from "fs";
-import * as child_process from "child_process";
 import * as tls from "tls";
-import { SocketFunction } from "../SocketFunction";
-import { isNode, isNodeTrue, sha256Hash } from "./misc";
-import { lazy } from "./caching";
 
 let trustedCerts = new Set<string>();
-let loadedTrustedCerts = false;
 let watchCallbacks = new Set<(certs: string[]) => void>();
 
-let storePath = isNodeTrue() && process.argv[1].replaceAll("\\", "/").split("/").slice(0, -1).join("/") + "/certstore/";
-if (isNode()) {
-    if (!fsSync.existsSync(storePath)) {
-        fsSync.mkdirSync(storePath);
-    }
-}
-
 /** Must be populated before the server starts */
-export async function trustUserCertificate(cert: string) {
+export function trustCertificate(cert: string | Buffer) {
+    cert = cert.toString();
     if (trustedCerts.has(cert)) return;
     trustedCerts.add(cert);
-    await fs.writeFile(storePath + sha256Hash(Buffer.from(cert)) + ".cer", cert);
-    let certs = getTrustedUserCertificates();
+    let certs = getTrustedCertificates();
     for (let callback of watchCallbacks) {
         callback(certs);
     }
 }
-export const loadTrustedUserCertificates = lazy(async () => {
-    let files = await fs.readdir(storePath);
-    for (let file of files) {
-        let cert = await fs.readFile(storePath + file, "utf8");
-        trustedCerts.add(cert);
-    }
-    loadedTrustedCerts = true;
-});
-export function getTrustedUserCertificates(): string[] {
-    if (!loadedTrustedCerts) {
-        throw new Error("Must call loadTrustedUserCertificates (and await it) before calling getTrustedUserCertificates");
-    }
-    return Array.from(trustedCerts);
+export function getTrustedCertificates(): string[] {
+    return tls.rootCertificates.concat(Array.from(trustedCerts));
 }
 
-export function watchUserCertificates(callback: (certs: string[]) => void) {
+export function watchTrustedCertificates(callback: (certs: string[]) => void) {
     watchCallbacks.add(callback);
-    callback(getTrustedUserCertificates());
+    callback(getTrustedCertificates());
     return () => watchCallbacks.delete(callback);
 }

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

@@ -3,28 +3,33 @@ import http from "http";
 import net from "net";
 import tls from "tls";
 import * as ws from "ws";
-import { getCertKeyPair, getNodeIdFromCert } from "./nodeAuthentication";
 import { getNodeIdsFromRequest, httpCallHandler } from "./callHTTPHandler";
 import { SocketFunction } from "../SocketFunction";
-import { getTrustedUserCertificates, loadTrustedUserCertificates, watchUserCertificates } from "./certStore";
+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 & {
+        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.
         public?: boolean;
         ip?: string;
 
-        /** If the SNI matches this domain, we use a different key/cert.
-         *  - Also requestCert may be specified (otherwise it defaults to true)
-         */
+        /** If the SNI matches this domain, we use a different key/cert. */
         SNICerts?: {
-            [domain: string]: https.ServerOptions;
+            [domain: string]: Watchable<https.ServerOptions>;
         };
     }
 );
@@ -32,25 +37,30 @@ export type SocketServerConfig = (
 export async function startSocketServer(
     config: SocketServerConfig
 ): Promise<string> {
-    let isSecure = "cert" in config || "key" in config || "pfx" in config;
-    if (!isSecure) {
-        let { key, cert } = getCertKeyPair();
-        config.key = key;
-        config.cert = cert;
-    }
-
 
     const webSocketServer = new ws.Server({
         noServer: true,
     });
 
-    await loadTrustedUserCertificates();
+    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;
 
-    function setupHTTPSServer(options: https.ServerOptions) {
-        let httpsServer = https.createServer(options);
-        watchUserCertificates(() => {
-            options.ca = tls.rootCertificates.concat(getTrustedUserCertificates());
-            httpsServer.setSecureContext(options);
+        watchTrustedCertificates(() => {
+            lastOptions.ca = getTrustedCertificates();
+            httpsServer.setSecureContext(lastOptions);
         });
 
         httpsServer.on("connection", socket => {
@@ -102,15 +112,19 @@ export async function startSocketServer(
     // TODO: Only allow unauthorized for ip certificates, and then for domains use the domain as the nodeId,
     //  so it is easy to read, and consistent.
     let options: https.ServerOptions = {
-        rejectUnauthorized: SocketFunction.rejectUnauthorized,
-        requestCert: true,
         ...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) {
@@ -137,10 +151,9 @@ export async function startSocketServer(
             if (buffer[0] !== 22) {
                 server = httpServer;
             } else {
-                debugbreak(1);
-                debugger;
                 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;
             }
 
@@ -169,18 +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}`);
 
-    console.log(`Started Listening on ${host}:${port}`);
+    return nodeId;
+}
 
-    let serverNodeId = getNodeIdFromCert({ raw: config.cert as Buffer | string }, port);
-    if (!serverNodeId) {
-        throw new Error(`Something is wrong with our cert, we don't have a nodeId?`);
-    }
-    return serverNodeId;
+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/websocketFactory.ts

@@ -0,0 +1,46 @@
+import ws from "ws";
+import tls from "tls";
+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) {
+    return (webSocket as any)._socket as tls.TLSSocket;
+}
+
+/** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
+ *      a different key/cert context.
+ */
+export function createWebsocketFactory(): (nodeId: string) => SenderInterface {
+
+    if (!isNode()) {
+        return (nodeId: string) => {
+            let location = getNodeIdLocation(nodeId);
+            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+
+            console.log(`Connecting to ${address}:${port}`);
+            return new WebSocket(`wss://${address}:${port}`);
+        };
+    } else {
+        return (nodeId: string) => {
+            let location = getNodeIdLocation(nodeId);
+            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+
+            console.log(`Connecting to ${address}:${port}`);
+            let webSocket = new ws.WebSocket(`wss://${address}:${port}`, {
+                ca: tls.rootCertificates.concat(getTrustedCertificates()),
+            });
+            let result = Object.assign(webSocket, { socket: undefined as tls.TLSSocket | undefined });
+            webSocket.once("upgrade", e => {
+                result.socket = e.socket as tls.TLSSocket;
+            });
+            return result;
+        };
+    }
+}
+

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: {},
-    }
+    })
 );

package/src/nodeAuthentication.ts

@@ -1,123 +0,0 @@
-import ws from "ws";
-import tls from "tls";
-import net from "net";
-import { getAppFolder } from "./storagePath";
-import fs from "fs";
-import child_process from "child_process";
-import { cacheWeak, lazy } from "./caching";
-import https from "https";
-import debugbreak from "debugbreak";
-import crypto from "crypto";
-import { isNode, sha256Hash } from "./misc";
-import { getArgs } from "./args";
-import { SenderInterface } from "./CallFactory";
-import { SocketFunction } from "../SocketFunction";
-import { getTrustedUserCertificates } from "./certStore";
-import { getClientNodeId, getNodeId, getNodeIdLocation } from "./nodeCache";
-
-export type CertInfo = { raw: Buffer | string; issuerCertificate: { raw: Buffer | string } };
-
-let certKeyPairOverride: { key: Buffer; cert: Buffer } | undefined;
-export function getCertKeyPair(): { key: Buffer; cert: Buffer } {
-    if (certKeyPairOverride) return certKeyPairOverride;
-    return getCertKeyPairBase();
-}
-const getCertKeyPairBase = lazy((): { key: Buffer; cert: Buffer } => {
-    // https://nodejs.org/en/knowledge/HTTP/servers/how-to-create-a-HTTPS-server/
-
-    let folder = getAppFolder();
-    let identityPrefix = getArgs().identity || "";
-    let keyPath = folder + identityPrefix + "key.pem";
-    let certPath = folder + identityPrefix + "cert.pem";
-    if (!fs.existsSync(keyPath) || !fs.existsSync(certPath)) {
-        child_process.execSync(`openssl genrsa -out "${keyPath}"`);
-        child_process.execSync(`openssl req -new -key "${keyPath}" -out csr.pem -subj "/CN=notused"`);
-        child_process.execSync(`openssl x509 -req -days 9999 -in csr.pem -signkey "${keyPath}" -out "${certPath}"`);
-        fs.rmSync("csr.pem");
-    }
-
-    let key = fs.readFileSync(keyPath);
-    let cert = fs.readFileSync(certPath);
-    return { key, cert };
-});
-
-export function overrideCertKeyPair<T>(certKey: { key: Buffer; cert: Buffer; }, code: () => T): T {
-    if (!isNode()) {
-        throw new Error(`Cannot override cert/key pair in browser`);
-    }
-    let prevOverride = certKeyPairOverride;
-    certKeyPairOverride = certKey;
-    try {
-        return code();
-    } finally {
-        certKeyPairOverride = prevOverride;
-    }
-}
-
-export function getTLSSocket(webSocket: ws.WebSocket) {
-    return (webSocket as any)._socket as tls.TLSSocket;
-}
-
-export async function getOwnNodeId() {
-    if (!isNode()) {
-        throw new Error(`Clientside nodeIds are not exposed to the client`);
-    }
-
-    // This is BASICALLY just sha256Hash(getCertKeyPari().cert), however... I'm not 100% the format
-    //  is the same, we would have to verify it. It isn't that important, other nodes know our nodeId,
-    //  and clients don't really have a reason to use this anyway (they can't verify it, they can only
-    //  really verify with a location).
-    throw new Error(`TODO: Implement getOwnNodeId`);
-}
-
-export function getNodeIdFromCert(certRaw: { raw: Buffer | string } | undefined, callbackPort: number | undefined) {
-    if (!certRaw?.raw) return undefined;
-    let cert = new crypto.X509Certificate(certRaw.raw);
-    if (!callbackPort) {
-        return getClientNodeId(cert.subject);
-    }
-    let subject = cert.subject;
-    if (subject.startsWith("CN=")) {
-        subject = subject.slice("CN=".length);
-    }
-    return getNodeId(subject, callbackPort);
-}
-
-/** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
- *      a different key/cert context.
- */
-export function createWebsocketFactory(): (nodeId: string) => SenderInterface {
-
-    if (!isNode()) {
-        return (nodeId: string) => {
-            let location = getNodeIdLocation(nodeId);
-            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
-            let { address, port } = location;
-
-            console.log(`Connecting to ${address}:${port}`);
-            return new WebSocket(`wss://${address}:${port}`);
-        };
-    } else {
-        let { key, cert } = getCertKeyPair();
-        let rejectUnauthorized = SocketFunction.rejectUnauthorized;
-        return (nodeId: string) => {
-            let location = getNodeIdLocation(nodeId);
-            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
-            let { address, port } = location;
-
-            console.log(`Connecting to ${address}:${port}`);
-            let webSocket = new ws.WebSocket(`wss://${address}:${port}`, {
-                cert,
-                key,
-                rejectUnauthorized,
-                ca: tls.rootCertificates.concat(getTrustedUserCertificates()),
-            });
-            let result = Object.assign(webSocket, { socket: undefined as tls.TLSSocket | undefined });
-            webSocket.once("upgrade", e => {
-                result.socket = e.socket as tls.TLSSocket;
-            });
-            return result;
-        };
-    }
-}
-