socket-function 0.5.0 → 0.6.0

package/{CallInstance.ts → src/CallFactory.ts}

@@ -1,10 +1,11 @@
-import { CallerContext, CallType, NetworkLocation } from "./SocketFunctionTypes";
+import { CallerContext, CallType, NetworkLocation } from "../SocketFunctionTypes";
 import type * as ws from "ws";
 import type * as net from "net";
 import { performLocalCall } from "./callManager";
-import { convertErrorStackToError } from "./misc";
+import { convertErrorStackToError, isNode } from "./misc";
 import { createWebsocket, getNodeId, getTLSSocket } from "./nodeAuthentication";
 import debugbreak from "debugbreak";
+import http from "http";
 
 const retryInterval = 2000;
 
@@ -46,7 +47,7 @@ export async function callFactoryFromLocation(
 }
 
 export async function callFactoryFromWS(
-    webSocket: ws.WebSocket
+    webSocket: ws.WebSocket & { nodeId?: string },
 ): Promise<CallFactory> {
     let socket = getTLSSocket(webSocket);
     let remoteAddress = socket.remoteAddress;
@@ -69,8 +70,19 @@ export async function callFactoryFromWS(
     return await createCallFactory(webSocket, location);
 }
 
+export interface SenderInterface {
+    nodeId?: string;
+
+    send(data: string): void;
+
+    on(event: "open", listener: () => void): this;
+    on(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "message", listener: (data: ws.RawData, isBinary: boolean) => void): this;
+}
+
 async function createCallFactory(
-    webSocketBase: ws.WebSocket | undefined,
+    webSocketBase: SenderInterface | undefined,
     location: NetworkLocation,
 ): Promise<CallFactory> {
 
@@ -99,14 +111,18 @@ async function createCallFactory(
 
     const pendingNodeId = "PENDING";
     let callerContext: CallerContext = { location, nodeId: pendingNodeId };
-    let webSocket!: ws.WebSocket;
+    let webSocket!: SenderInterface;
     if (!webSocketBase) {
         await tryToReconnect();
     } else {
         webSocket = webSocketBase;
         setupWebsocket(webSocketBase);
     }
-    callerContext.nodeId = getNodeId(webSocket);
+    if (isNode()) {
+        callerContext.nodeId = getNodeId(webSocket);
+    } else {
+        callerContext.nodeId = location.address + ":" + location.listeningPorts[0];
+    }
 
     niceConnectionName = `${niceConnectionName} (${callerContext.nodeId})`;
 
@@ -121,7 +137,7 @@ async function createCallFactory(
                 if (reconnectTimeout) {
                     await Promise.race([
                         reconnectingPromise,
-                        new Promise<ws.WebSocket>(resolve =>
+                        new Promise<SenderInterface>(resolve =>
                             setTimeout(() => {
                                 retriesEnabled = false;
                                 resolve(webSocket);
@@ -173,13 +189,13 @@ async function createCallFactory(
                 setupWebsocket(newWebSocket);
 
                 let connectError = await new Promise<string | undefined>(resolve => {
-                    newWebSocket.once("open", () => {
+                    newWebSocket.on("open", () => {
                         resolve(undefined);
                     });
-                    newWebSocket.once("close", () => {
+                    newWebSocket.on("close", () => {
                         resolve("Connection closed for non-error reason?");
                     });
-                    newWebSocket.once("error", e => {
+                    newWebSocket.on("error", e => {
                         resolve(String(e.stack));
                     });
                 });
@@ -187,14 +203,17 @@ async function createCallFactory(
                 if (!connectError) {
                     console.log(`Reconnected to ${location.address}:${port}`);
 
-                    let newNodeId = getNodeId(newWebSocket);
-
-                    let prevNodeId = callerContext.nodeId;
-                    if (prevNodeId === pendingNodeId) {
-                        callerContext.nodeId = newNodeId;
-                    } else {
-                        if (newNodeId !== prevNodeId) {
-                            throw new Error(`Connection lost to at ${niceConnectionName} ("${prevNodeId}"), but then re-established, however it is now "${newNodeId}"!`);
+                    // NOTE: Clientside doesn't have access to peer certificates, so it can't know the nodeId of the server
+                    //  that way. However, it can 
+                    if (isNode()) {
+                        let newNodeId = getNodeId(newWebSocket);
+                        let prevNodeId = callerContext.nodeId;
+                        if (prevNodeId === pendingNodeId) {
+                            callerContext.nodeId = newNodeId;
+                        } else {
+                            if (newNodeId !== prevNodeId) {
+                                throw new Error(`Connection lost to at ${niceConnectionName} ("${prevNodeId}"), but then re-established, however it is now "${newNodeId}"!`);
+                            }
                         }
                     }
 
@@ -225,23 +244,30 @@ async function createCallFactory(
         })();
     }
 
-    function setupWebsocket(webSocket: ws.WebSocket) {
+    function setupWebsocket(webSocket: SenderInterface) {
         webSocket.on("error", e => {
             console.log(`Websocket error for ${niceConnectionName}`, e);
         });
 
         webSocket.on("close", async () => {
             console.log(`Websocket closed ${niceConnectionName}`);
-            await tryToReconnect();
+            if (retriesEnabled) {
+                await tryToReconnect();
+            }
         });
 
         webSocket.on("message", onMessage);
     }
 
 
-    async function onMessage(message: ws.RawData) {
+    async function onMessage(message: ws.RawData | MessageEvent | string) {
         try {
-            if (message instanceof Buffer) {
+            if (!isNode()) {
+                if (typeof message === "object" && "data" in message) {
+                    message = message.data;
+                }
+            }
+            if (message instanceof Buffer || typeof message === "string") {
                 let call = JSON.parse(message.toString()) as InternalCallType | InternalReturnType;
                 if (call.isReturn) {
                     let callbackObj = pendingCalls.get(call.seqNum);

package/{caching.ts → src/caching.ts}

@@ -2,10 +2,10 @@ import { arrayEqual } from "./misc";
 import { AnyFunction, Args, canHaveChildren } from "./types";
 
 export function lazy<T>(factory: () => T): () => T {
-    let value: { value: T }|undefined = undefined;
+    let value: { value: T } | undefined = undefined;
 
     return () => {
-        if(!value) {
+        if (!value) {
             value = { value: factory() };
         }
         return value.value;

package/src/callHTTPHandler.ts

@@ -0,0 +1,160 @@
+import https from "https";
+import http from "http";
+import net from "net";
+import tls from "tls";
+import { CallerContext, CallType } from "../SocketFunctionTypes";
+import { performLocalCall } from "./callManager";
+import { getNodeIdRaw } from "./nodeAuthentication";
+import debugbreak from "debugbreak";
+import * as cookie from "cookie";
+
+const nodeIdCookie = "node-id3";
+
+let defaultHTTPCall: CallType | undefined;
+
+export function setDefaultHTTPCall(call: CallType) {
+    defaultHTTPCall = call;
+}
+
+export function getNodeIdFromRequest(request: http.IncomingMessage): string | undefined {
+    let cookies = cookie.parse(request.headers.cookie ?? "");
+    return cookies[nodeIdCookie];
+}
+
+export async function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse) {
+    try {
+
+        let urlBase = request.url;
+        if (!urlBase) {
+            throw new Error("Missing URL");
+        }
+        if (urlBase === "/favicon.ico") {
+            response.end();
+            return;
+        }
+
+        let protocol = "https";
+        let url = protocol + "://" + request.headers.host + request.url;
+
+        console.log(`HTTP request (${request.method}) ${url}`);
+        let urlObj = new URL(url);
+
+        let payload = await new Promise<Buffer>((resolve, reject) => {
+            let data: Buffer[] = [];
+            request
+                .on("data", chunk => data.push(chunk))
+                .on("end", () => resolve(Buffer.concat(data)))
+                .on("error", (err) => reject(err))
+                ;
+        });
+
+        let socket = request.connection as tls.TLSSocket;
+
+        let address = socket.remoteAddress;
+        let port = socket.remotePort;
+        if (!address) {
+            throw new Error("Missing remote address");
+        }
+        if (!port) {
+            throw new Error("Missing remote port");
+        }
+
+        let nodeId = getNodeIdRaw(socket);
+        if (!nodeId) {
+            let headerNodeId = cookie.parse(request.headers.cookie || "")[nodeIdCookie];
+            if (typeof headerNodeId === "string") {
+                nodeId = headerNodeId;
+            }
+        }
+        if (!nodeId) {
+            nodeId = "HTTP_nodeId_" + Date.now() + "_" + Math.random();
+            response.setHeader("Set-Cookie", cookie.serialize(nodeIdCookie, nodeId, {
+                httpOnly: true,
+                path: "/",
+                secure: true,
+                domain: urlObj.hostname,
+                sameSite: "none"
+            }));
+
+            response.setHeader(nodeIdCookie, nodeId);
+        }
+
+        let caller: CallerContext = {
+            nodeId,
+            location: {
+                address,
+                localPort: port,
+                listeningPorts: [],
+            }
+        };
+
+        let classGuid = urlObj.searchParams.get("classGuid");
+        let functionName = urlObj.searchParams.get("functionName");
+        let args: string | unknown[] | null = urlObj.searchParams.get("args");
+
+        if (!classGuid) {
+            if (defaultHTTPCall) {
+                classGuid = defaultHTTPCall.classGuid;
+                functionName = defaultHTTPCall.functionName;
+                args = defaultHTTPCall.args;
+            } else {
+                throw new Error("Missing classGuid in URL query");
+            }
+        }
+        if (!functionName) {
+            throw new Error("Missing functionName in URL query");
+        }
+
+        if (!args) {
+            args = [];
+        } else {
+            if (typeof args === "string") {
+                args = JSON.parse(args) as unknown[];
+            }
+        }
+
+        if (payload.length > 0) {
+            args = JSON.parse(payload.toString())["args"] as unknown[];
+        }
+
+        let call: CallType = {
+            classGuid,
+            functionName,
+            args,
+        };
+
+        let result = await performLocalCall({
+            caller,
+            call
+        });
+
+        if (typeof result === "object" && result && result instanceof Buffer) {
+            let headers = (result as HTTPResultType)[resultHeaders];
+            if (headers) {
+                for (let headerName in headers) {
+                    response.setHeader(headerName, headers[headerName]);
+                }
+            }
+            response.write(result);
+        } else {
+            response.write(JSON.stringify(result));
+        }
+        response.end();
+    } catch (e: any) {
+        console.error(`Request error`, e.stack);
+        response.writeHead(500, String(e.message));
+        response.end();
+    }
+}
+
+
+const resultHeaders = Symbol("resultHeaders");
+type HTTPResultType = Buffer & { [resultHeaders]?: { [header: string]: string } };
+
+export function setHTTPResultHeaders(
+    result: HTTPResultType,
+    headers: { [header: string]: string },
+): HTTPResultType {
+    result[resultHeaders] = headers;
+    return result;
+}

package/{callManager.ts → src/callManager.ts}

@@ -1,14 +1,13 @@
-import { CallContextType, CallerContext, CallType, ClientHookContext, HookContext, NetworkLocation, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "./SocketFunctionTypes";
-import { _setSocketContext } from "./SocketFunction";
+import { CallContextType, CallerContext, CallType, ClientHookContext, HookContext, NetworkLocation, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+import { _setSocketContext } from "../SocketFunction";
 
 let classes: {
     [classGuid: string]: {
-        classType: SocketExposedInterfaceClass;
         controller: SocketExposedInterface;
         shape: SocketExposedShape;
     }
 } = {};
-let exposedClasses = new Set<SocketExposedInterfaceClass>();
+let exposedClasses = new Set<string>();
 
 let globalHooks: SocketFunctionHook[] = [];
 let globalClientHooks: SocketFunctionClientHook[] = [];
@@ -26,7 +25,7 @@ export async function performLocalCall(
         throw new Error(`Class ${call.classGuid} not found`);
     }
 
-    if (!exposedClasses.has(classDef.classType)) {
+    if (!exposedClasses.has(call.classGuid)) {
         throw new Error(`Class ${call.classGuid} not exposed`);
     }
 
@@ -55,20 +54,19 @@ export async function performLocalCall(
     return await result;
 }
 
-export function registerClass(classGuid: string, exposedClass: SocketExposedInterfaceClass, shape: SocketExposedShape) {
+export function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape) {
     if (classes[classGuid]) {
         throw new Error(`Class ${classGuid} already registered`);
     }
 
     classes[classGuid] = {
-        classType: exposedClass,
-        controller: new exposedClass() as SocketExposedInterface,
+        controller,
         shape,
     };
 }
 
-export function exposeClass(exposedClass: SocketExposedInterfaceClass) {
-    exposedClasses.add(exposedClass);
+export function exposeClass(exposedClass: SocketRegistered) {
+    exposedClasses.add(exposedClass._classGuid);
 }
 
 export function registerGlobalHook(hook: SocketFunctionHook) {

package/{misc.ts → src/misc.ts}

@@ -19,9 +19,14 @@ export function arrayEqual(a: unknown[], b: unknown[]) {
     }
     return true;
 }
+export function isNode() {
+    return typeof document === "undefined";
+}
 
 
-// TODO: Find a better place for this...
-process.on("unhandledRejection", async (reason: any, promise) => {
-    console.error(`Uncaught promise rejection: ${String(reason.stack || reason)}`);
-});
+if (isNode()) {
+    // TODO: Find a better place for this...
+    process.on("unhandledRejection", async (reason: any, promise) => {
+        console.error(`Uncaught promise rejection: ${String(reason.stack || reason)}`);
+    });
+}

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

@@ -1,5 +1,6 @@
 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";
@@ -7,12 +8,17 @@ import { cacheWeak, lazy } from "./caching";
 import https from "https";
 import debugbreak from "debugbreak";
 import crypto from "crypto";
-import { sha256Hash } from "./misc";
+import { isNode, sha256Hash } from "./misc";
 import { getArgs } from "./args";
+import { SenderInterface } from "./CallFactory";
 
 export const getCertKeyPair = lazy((): { key: Buffer; cert: Buffer } => {
     // TODO: Also get this working clientside...
     //  - Probably using node-forge, maybe using this as an example: https://github.com/jfromaniello/selfsigned/blob/master/index.js
+    //  - ALSO, get our nodeId set in our cookies, so HTTP requests can work as well
+    //      - We will need to call some kind of endpoint to do this?
+    //  - Then download the certs and try to get the user to install them, so chrome can use
+    //      them? Otherwise there is no point of having certs clientside.
 
     // https://nodejs.org/en/knowledge/HTTP/servers/how-to-create-a-HTTPS-server/
 
@@ -36,27 +42,70 @@ export function getTLSSocket(webSocket: ws.WebSocket) {
     return (webSocket as any)._socket as tls.TLSSocket;
 }
 
-export const getNodeId = cacheWeak(function (webSocket: ws.WebSocket): string {
+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 const getNodeId = cacheWeak(function (webSocket: SenderInterface | ws.WebSocket & { nodeId?: string }): string {
+    if (!(webSocket instanceof ws.WebSocket)) {
+        if (!webSocket.nodeId) {
+            throw new Error("Sender isn't a WebSocket, and doesn't have a nodeId");
+        }
+        return webSocket.nodeId;
+    }
     let socket = getTLSSocket(webSocket);
+    let nodeId = getNodeIdRaw(socket);
+    if (!nodeId) {
+        if (webSocket.nodeId) {
+            return webSocket.nodeId;
+        }
+        throw new Error(`Peer certificate must use an RSA key or EC key (which should have a .pubkey property)`);
+    }
+    return nodeId;
+});
+
+export function getNodeIdRaw(socket: tls.TLSSocket) {
     let peerCert = socket.getPeerCertificate();
     if (!peerCert) {
         throw new Error("WebSocket connections must provided a peer certificate");
     }
     let pubkey = (peerCert as any).pubkey as Buffer | undefined;
     if (!pubkey) {
-        throw new Error(`Peer certificate must use an RSA key or EC key (which should have a .pubkey property)`);
+        return undefined;
     }
     return sha256Hash(pubkey);
-});
+}
 
-export function createWebsocket(address: string, port: number): ws.WebSocket {
-    let { key, cert } = getCertKeyPair();
+export function createWebsocket(address: string, port: number): SenderInterface {
     console.log(`Connecting to ${address}:${port}`);
-    return new ws.WebSocket(`wss://${address}:${port}`, {
-        cert,
-        key,
-        rejectUnauthorized: false,
-    });
+    if (!isNode()) {
+        // NOTE: We assume an HTTP request has already been made, which will setup a nodeId cookie
+        //  (And as this point we can't even use peer certificates if we wanted to, as this must be done
+        //      directly in the browser)
+        let webSocket = new WebSocket(`wss://${address}:${port}`);
+        return Object.assign(webSocket, {
+            on(event: string, callback: any) {
+                // TODO: Use better type safety here
+                (webSocket as any)["on" + event] = callback;
+                return this as any;
+            },
+        });
+    } else {
+        let { key, cert } = getCertKeyPair();
+        return new ws.WebSocket(`wss://${address}:${port}`, {
+            cert,
+            key,
+            rejectUnauthorized: false,
+        });
+    }
 }
 
 

package/{nodeCache.ts → src/nodeCache.ts}

@@ -1,5 +1,5 @@
-import { callFactoryFromLocation, CallFactory } from "./CallInstance";
-import { NetworkLocation } from "./SocketFunctionTypes";
+import { callFactoryFromLocation, CallFactory } from "./CallFactory";
+import { NetworkLocation } from "../SocketFunctionTypes";
 import { MaybePromise } from "./types";
 
 // TODO: Add CallInstanceFactory.isClosed, so nodeCache can clean up old entries.
@@ -74,6 +74,6 @@ export function getCreateCallFactoryLocation(location: NetworkLocation): MaybePr
 
 
 // TODO: Give a special error if the nodeId has been seen, but is only one-way (from HTTP requests).
-export function getCallFactoryNodeId(nodeId: string): CallFactory|undefined {
+export function getCallFactoryNodeId(nodeId: string): CallFactory | undefined {
     return nodeCache.get(nodeId)?.callFactory;
 }

package/{nodeProxy.ts → src/nodeProxy.ts}

@@ -1,5 +1,5 @@
 import { lazy } from "./caching";
-import { SocketExposedInterface } from "./SocketFunctionTypes";
+import { SocketExposedInterface } from "../SocketFunctionTypes";
 
 //todonext
 //  We need some sort of cache, but... maybe not here?
@@ -12,13 +12,13 @@ type CallProxyType = {
 let proxyCache = new Map<string, CallProxyType>();
 export function getCallProxy(id: string, callback: (controllerName: string, functionName: string, args: unknown[]) => Promise<unknown>): CallProxyType {
     let value = proxyCache.get(id);
-    if(!value) {
+    if (!value) {
         let controllerCache = new Map<string, CallProxyType[""]>();
         value = new Proxy(Object.create(null), {
             get(target, controllerName) {
-                if(typeof controllerName !== "string") return undefined;
+                if (typeof controllerName !== "string") return undefined;
                 let controller = controllerCache.get(controllerName);
-                if(!controller) {
+                if (!controller) {
                     controller = new Proxy(Object.create(null), {
                         get(target, functionName) {
                             if (typeof functionName !== "string") return undefined;