stuff

lib/src/backend/RPCSocketServer.d.ts

 declare type rpcType = 'hook' | 'unhook' | 'call';
 declare type visibility = 'public' | 'private';
 export declare type Outcome = "Success" | "Error";
+export declare type Visibility = "127.0.0.1" | "0.0.0.0";
 export declare class Response {
     message?: string | undefined;
     constructor(message?: string | undefined);
 export declare class RPCSocketServer {
     private port;
     private rpcExporters;
+    private visibility;
     private conf;
     private io;
     private wsServer;
-    constructor(port: number, rpcExporters?: RPCExporter[], conf?: RPCSocketConf);
+    constructor(port: number, rpcExporters?: RPCExporter[], visibility?: Visibility, conf?: RPCSocketConf);
     private startWebsocket;
     protected initApis(socket: any): void;
 }

lib/src/backend/RPCSocketServer.js

     return ret;
 };
 class RPCSocketServer {
-    constructor(port, rpcExporters = [], conf = {
+    constructor(port, rpcExporters = [], visibility = "127.0.0.1", conf = {
         errorHandler: (socket) => (error) => { socket.destroy(); console.error(error); },
         closeHandler: (socket) => () => { console.log("Socket closing"); },
         connectionHandler: (socket) => { console.log("New websocket connection in port " + socket.port); }
     }) {
         this.port = port;
         this.rpcExporters = rpcExporters;
+        this.visibility = visibility;
         this.conf = conf;
         this.io = bsock.createServer();
         this.wsServer = http.createServer();
                 socket.on('close', this.conf.closeHandler(socket));
                 this.initApis(socket);
             });
-            this.wsServer.listen(this.port);
+            this.wsServer.listen(this.port, this.visibility);
         }
         catch (e) {
             //@ts-ignore

src/backend/RPCSocketServer.ts

 import { Socket } from "./RPCSocketServer"
 
 type rpcType = 'hook' | 'unhook' | 'call'
-type visibility = 'public' | 'private'
-
 export type Outcome = "Success" | "Error"
+export type Visibility = "127.0.0.1" | "0.0.0.0"
 
 /* Responses */
 export class Response{
 type baseRPC = { 
     type: rpcType
     name: string
-    visibility: visibility
 }
 
 type hookRPC = baseRPC & {
     constructor(
         private port:number,
         private rpcExporters: RPCExporter[] = [],
+        private visibility: Visibility = "127.0.0.1",
         private conf: RPCSocketConf = {
             errorHandler: (socket:Socket) => (error:any) => { socket.destroy(); console.error(error) },
             closeHandler: (socket:Socket) => () => { console.log("Socket closing") },
                 socket.on('close', this.conf.closeHandler(socket))
                 this.initApis(socket)
             })
-            this.wsServer.listen(this.port)
+            this.wsServer.listen(this.port, this.visibility)
         }catch(e){
             //@ts-ignore
             this.errorHandler(undefined)("Unable to connect to socket")