fix

lib/src/backend/RPCSocketServer.d.ts

 import { Socket } from "./RPCSocketServer";
 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 {
 export interface RPCExporter {
     name: string;
     exportRPCs(): socketioRPC[];
+    exportPublicRPCs(): socketioRPC[];
 }
 declare type baseRPC = {
     type: rpcType;
     name: string;
-    visibility: visibility;
 };
 declare type hookRPC = baseRPC & {
     type: 'hook';
 export declare const rpcToRpcinfo: (rpc: socketioRPC, owner: string) => RpcInfo;
 export declare const rpcHooker: (socket: Socket, owner: string, RPCs: socketioRPC[], makeUnique?: boolean) => ExtendedRpcInfo[];
 declare type OnFunction = (type: 'error' | 'close', f: (e?: any) => void) => Socket;
-export declare type Socket = {
+export interface Socket {
     port: number;
     hook: (rpcname: string, ...args: any[]) => Socket;
     unhook: (rpcname: string) => Socket;
     on: OnFunction;
     destroy: () => void;
     close: () => void;
-};
+}
 export declare type RPCSocketConf = {
     connectionHandler: (socket: Socket) => void;
     errorHandler: (socket: Socket) => (error: any) => void;
     private wsServer;
     constructor(port: number, rpcExporters?: RPCExporter[], visibility?: Visibility, conf?: RPCSocketConf);
     private startWebsocket;
-    protected initApis(socket: any): void;
+    protected initApis(socket: Socket): void;
+    protected initPublicApis(socket: Socket): void;
 }
 export {};

lib/src/backend/RPCSocketServer.js

                 owner: owner,
                 argNames: extractArgs(rpc.func),
                 type: rpc.type,
-                visibility: rpc.visibility,
                 name: rpc.name,
                 func: rpc.func,
             };
                 owner: owner,
                 argNames: extractArgs(rpc.func),
                 type: rpc.type,
-                visibility: rpc.visibility,
                 name: rpc.name,
                 func: rpc.func,
             };
                 owner: owner,
                 argNames: extractArgs(generator(undefined)),
                 type: rpc.type,
-                visibility: rpc.visibility,
                 name: rpc.name,
                 unhook: rpc.unhook,
                 generator: generator,
             this.io.on('socket', (socket) => {
                 socket.on('error', this.conf.errorHandler(socket));
                 socket.on('close', this.conf.closeHandler(socket));
-                this.initApis(socket);
+                if (this.visibility === "127.0.0.1")
+                    this.initApis(socket);
+                else
+                    this.initPublicApis(socket);
             });
             this.wsServer.listen(this.port, this.visibility);
         }
             {
                 name: 'info',
                 type: 'call',
-                visibility: 'private',
                 func: async () => rpcInfos
             }
         ];
         const rpcInfos = [
             ...exports.rpcHooker(socket, "Admin", adminRPCs, false),
-            ...this.rpcExporters.flatMap(exporter => exports.rpcHooker(socket, exporter.name, exporter.exportRPCs()))
+            ...this.rpcExporters.flatMap(exporter => exports.rpcHooker(socket, exporter.name, [...exporter.exportPublicRPCs(), ...exporter.exportRPCs()]))
+        ];
+    }
+    initPublicApis(socket) {
+        const adminRPCs = [
+            {
+                name: 'info',
+                type: 'call',
+                func: async () => rpcInfos
+            }
+        ];
+        const rpcInfos = [
+            ...exports.rpcHooker(socket, "Admin", adminRPCs, false),
+            ...this.rpcExporters.flatMap(exporter => exports.rpcHooker(socket, exporter.name, exporter.exportPublicRPCs()))
         ];
     }
 }

lib/src/frontend/RPCaller.d.ts → lib/src/frontend/RPCSocket.d.ts

-declare type RPCReceiver = {
-    [RPCGroup in string]: any;
-};
+import { Socket } from "../backend/RPCSocketServer";
 /**
  * Dynamic library to communicate with FrontblockService remotely
  *
  * Will ask it's service for available RPCs and parse them into methods of this object
  * for convenient access.
  */
-export declare class RPCaller implements RPCReceiver {
+export declare class RPCSocket implements Socket {
+    port: number;
+    private server;
+    private tls;
     private socket;
     constructor(port: number, server: string, tls?: boolean);
+    hook(name: any, args: any): Socket;
+    unhook(name: any): Socket;
+    on(type: "error" | "close", f: (e?: any) => void): Socket;
+    destroy(): void;
+    close(): void;
+    call(rpcname: string, ...args: any[]): Promise<any>;
+    fire(rpcname: string, ...args: any[]): Promise<any>;
     connect(): Promise<void>;
     info(): Promise<any>;
     private callGenerator;
     private hookGenerator;
     private unhookGenerator;
 }
-export {};

lib/src/frontend/RPCaller.js → lib/src/frontend/RPCSocket.js

  * Will ask it's service for available RPCs and parse them into methods of this object
  * for convenient access.
  */
-class RPCaller {
+class RPCSocket {
     constructor(port, server, tls = false) {
-        this.socket = bsock.connect(port, server, tls);
+        this.port = port;
+        this.server = server;
+        this.tls = tls;
+    }
+    hook(name, args) {
+        return this.socket.hook(name, args);
+    }
+    unhook(name) {
+        return this.socket.unhook(name);
+    }
+    on(type, f) {
+        return this.socket.on(type, name);
+    }
+    destroy() {
+        return this.socket.destroy();
+    }
+    close() {
+        return this.socket.close();
+    }
+    async call(rpcname, ...args) {
+        return await this.socket.call.apply(this.socket, [rpcname, ...args]);
+    }
+    async fire(rpcname, ...args) {
+        return await this.socket.fire.apply(this.socket, [rpcname, ...args]);
     }
     async connect() {
+        this.socket = await bsock.connect(this.port, this.server, this.tls);
         const info = await this.info();
         info.forEach(i => {
             let f;
                         } )()`);
     }
 }
-exports.RPCaller = RPCaller;
+exports.RPCSocket = RPCSocket;

lib/test/test.js

 Object.defineProperty(exports, "__esModule", { value: true });
 const RPCSocketServer_1 = require("../src/backend/RPCSocketServer");
 //@ts-ignore
-const RPCaller_1 = require("../src/frontend/RPCaller");
+const RPCSocket_1 = require("../src/frontend/RPCSocket");
 new RPCSocketServer_1.RPCSocketServer(20000, [{
         name: "HelloWorldRPCGroup",
+        exportPublicRPCs: () => [],
         exportRPCs: () => [{
                 type: 'call',
                 name: 'echo',
                 func: async (s) => s,
-                visibility: 'private'
-            }]
-    }]);
-const caller = new RPCaller_1.RPCaller(20000, 'localhost');
+            }],
+    }], "0.0.0.0");
+const caller = new RPCSocket_1.RPCSocket(20000, 'localhost');
 caller.connect().then(_ => {
     caller.info().then(console.log);
     caller["HelloWorldRPCGroup"].echo("x").then(console.log);

src/backend/RPCSocketServer.ts

 export interface RPCExporter{
     name: string
     exportRPCs() : socketioRPC[]
+    exportPublicRPCs() : socketioRPC[]
 }
 
 type baseRPC = { 
                 owner: owner,
                 argNames: extractArgs(rpc.func),
                 type: rpc.type,
-                visibility: rpc.visibility,
                 name: rpc.name,
                 func: rpc.func,
             }
                 owner: owner,
                 argNames: extractArgs(rpc.func),
                 type: rpc.type,
-                visibility: rpc.visibility,
                 name: rpc.name,
                 func: rpc.func,
             }
                 owner: owner,
                 argNames: extractArgs(generator(undefined)),
                 type: rpc.type,
-                visibility: rpc.visibility,
                 name: rpc.name,
                 unhook: rpc.unhook,
                 generator: generator,
 
 type OnFunction = (type: 'error' | 'close', f: (e?:any)=>void) => Socket
 
-export type Socket = {
+export interface Socket {
     port: number
     hook: (rpcname: string, ...args: any[]) => Socket
     unhook: (rpcname:string) => Socket
             this.io.on('socket', (socket:Socket) => {
                 socket.on('error', this.conf.errorHandler(socket))
                 socket.on('close', this.conf.closeHandler(socket))
-                this.initApis(socket)
+                if(this.visibility === "127.0.0.1")
+                    this.initApis(socket)
+                else
+                    this.initPublicApis(socket)
             })
             this.wsServer.listen(this.port, this.visibility)
         }catch(e){
         }
     }
 
-    protected initApis(socket){
+    protected initApis(socket:Socket){
         const adminRPCs:socketioRPC[] = [
             {
                 name: 'info',
                 type: 'call',
-                visibility: 'private',
                 func: async () => rpcInfos
             }
         ]
 
         const rpcInfos:ExtendedRpcInfo[] = [
             ...rpcHooker(socket, "Admin", adminRPCs, false),
-            ...this.rpcExporters.flatMap(exporter => rpcHooker(socket, exporter.name, exporter.exportRPCs()))
+            ...this.rpcExporters.flatMap(exporter => rpcHooker(socket, exporter.name, [...exporter.exportPublicRPCs(), ...exporter.exportRPCs()]))
+        ]
+    }
+
+    protected initPublicApis(socket:Socket){
+        const adminRPCs:socketioRPC[] = [
+            {
+                name: 'info',
+                type: 'call',
+                func: async () => rpcInfos
+            }
+        ]
+
+        const rpcInfos:ExtendedRpcInfo[] = [
+            ...rpcHooker(socket, "Admin", adminRPCs, false),
+            ...this.rpcExporters.flatMap(exporter => rpcHooker(socket, exporter.name, exporter.exportPublicRPCs()))
         ]
     }
 }

src/frontend/RPCaller.ts → src/frontend/RPCSocket.ts

-import { ExtendedRpcInfo, UnhookFunction, callbackFunction, AsyncFunction } from "../backend/RPCSocketServer";
+import { ExtendedRpcInfo, UnhookFunction, callbackFunction, AsyncFunction, Socket } from "../backend/RPCSocketServer";
 var bsock = require('bsock')
 
 //fix args with defaults like "force = true" -> "force"
     return str.split("=")[0]
 }
 
-type RPCReceiver = {
-    [RPCGroup in string]: any
-}
 
 /**
  * Dynamic library to communicate with FrontblockService remotely
  * Will ask it's service for available RPCs and parse them into methods of this object
  * for convenient access.
  */
-export class RPCaller implements RPCReceiver{
-    private socket
-    
-    constructor(port:number, server: string, tls: boolean = false){
-        this.socket = bsock.connect(port, server, tls)
+export class RPCSocket implements Socket{
+    private socket: Socket
+    constructor(public port:number, private server: string, private tls: boolean = false){
     }
 
+    hook(name, args){
+        return this.socket.hook(name, args)
+    }
+
+    unhook(name){
+        return this.socket.unhook(name)
+    }
+
+    on(type: "error" | "close", f: (e?: any) => void){
+        return this.socket.on(type, name)
+    }
+
+    destroy(){
+        return this.socket.destroy()
+    }
+
+    close(){
+        return this.socket.close()
+    }
+
+    async call (rpcname: string, ...args: any[]) : Promise<any>{
+        return await this.socket.call.apply(this.socket, [rpcname, ...args])
+    }
+
+    async fire(rpcname: string, ...args: any[]) : Promise<any>{
+        return await this.socket.fire.apply(this.socket, [rpcname, ...args])
+    }
+    
     async connect(){
+        this.socket = await bsock.connect(this.port, this.server, this.tls)
+
         const info:ExtendedRpcInfo[] = await this.info()
         info.forEach(i => {
             let f: any

src/frontend/webpack.prod.js

 module.exports = {
   mode: 'production',
   target: "web",
-  entry: path.resolve(__dirname, 'RPCaller.ts'),
+  entry: path.resolve(__dirname, 'RPCSocket.ts'),
   output: {
       path: path.resolve(__dirname, '../../lib'),
       filename: 'RPCaller.min.js',

test/test.ts

 import { RPCSocketServer } from '../src/backend/RPCSocketServer'
 //@ts-ignore
-import {RPCaller} from '../src/frontend/RPCaller'
+import {RPCSocket} from '../src/frontend/RPCSocket'
 
 new RPCSocketServer(20000, [{
     name: "HelloWorldRPCGroup",
+    exportPublicRPCs: () => [],
     exportRPCs: () => [{
         type: 'call',
         name: 'echo',
         func: async (s:string) => s,
-        visibility: 'private'
-    }]
-}] )
+    }],
+}])
 
-const caller = new RPCaller(20000, 'localhost')
+const caller = new RPCSocket(20000, 'localhost')
 caller.connect().then(_ => {
     caller.info().then(console.log)
     caller["HelloWorldRPCGroup"].echo("x").then(console.log)