@siemsiem/tonpleun 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@siemsiem/tonpleun",
+  "version": "0.1.0",
+  "description": "uhhh dit zijn zeer goede docs (nee) tonpleun is een websocket server die websocket clients verzoeken laat maken aan andere websocket clients die zich als service registreren. voor nu is tonpleun in js maar wrs moet ik het porten naar python omdat ik dan meer code kan hergebruiken voor andere projecten.",
+  "keywords": [],
+  "homepage": "https://github.com/supersiem/Tonpleun#readme",
+  "bugs": {
+    "url": "https://github.com/supersiem/Tonpleun/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/supersiem/Tonpleun.git"
+  },
+  "license": "UNLICENSED",
+  "author": "Siemvk",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "tsc && clear && node ./dist/server.js",
+    "test": "tsc && clear && node ./dist/client.js",
+    "testDeTest": "tsc && clear && node ./dist/client2.js",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@types/ws": "^8.18.1",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "packageManager": "pnpm@10.12.1"
+}

package/readme.md

@@ -0,0 +1,28 @@
+# tonpleun  
+
+uhhh dit zijn zeer goede docs (nee)
+tonpleun is een websocket server die websocket clients verzoeken laat maken aan andere websocket clients die zich als service registreren.
+voor nu is tonpleun in js maar wrs moet ik het porten naar python omdat ik dan meer code kan hergebruiken voor andere projecten.
+
+## Installatie
+
+gebruik dit gewoon niet...
+
+maar als je het toch wilt gebruiken download de repo compile het met tsc en run main.js met node.
+
+## Gebruik
+
+gebruik het niet  
+maar als je onverstandig genoeg bent om het toch te gebruiken gebruik lib.ts om een client te maken die verbinding maakt met de tonpleun server.
+
+## Configuratie
+
+tonpleun heeft geen configuratie opties.
+
+## Licentie
+
+heel eerlijk het boeit me niet wat je doet met deze slechte code dus doe er mee wat je wilt.
+
+## Bijdragen
+
+uhhhhh maak een pr ofzo.  

package/src/client.ts

@@ -0,0 +1,43 @@
+import { getService, initializeClient, registerService, ws, registerConfigItem, SetConfigItem, getConfigValue } from './clientLib.js'
+import assert from 'node:assert/strict';
+function echo(args: any[]) {
+  console.log(args)
+  return 'pindakaas'
+}
+async function main() {
+  await initializeClient('testClient');
+  console.log(await registerService('echo', ['string'], echo))
+  console.log(await getService('getServices', 'tonpleun', []))
+  // Config tests: register and update a config item, then verify via tonpleun service
+  await registerConfigItem('greeting', 'Simple greeting config', 'hello', 'conf:greeting');
+  const configsAfterRegister: any = await getService('getConfigs', 'tonpleun', []);
+  assert.ok(configsAfterRegister['testClient'], 'configs for testClient should exist');
+  assert.ok(configsAfterRegister['testClient']['conf:greeting'], 'conf:greeting should be registered');
+  assert.equal(configsAfterRegister['testClient']['conf:greeting'].defaultValue, 'hello');
+  console.log('[Client1] registered config OK');
+
+  await SetConfigItem('conf:greeting', 'hi');
+  const configsAfterSet: any = await getService('getConfigs', 'tonpleun', []);
+  assert.equal(configsAfterSet['testClient']['conf:greeting'].value, 'hi');
+  console.log('[Client1] set config value OK');
+  assert.equal(getConfigValue('conf:greeting'), 'hi');
+  console.log('[Client1] local config value OK');
+  // Wait for a potential remote update (e.g., from Client2) and verify locally
+  await new Promise<void>((resolve) => {
+    const expected = 'bye';
+    const start = Date.now();
+    const interval = setInterval(() => {
+      const current = getConfigValue('conf:greeting');
+      if (current === expected) {
+        clearInterval(interval);
+        console.log('[Client1] remote config update applied OK');
+        resolve();
+      } else if (Date.now() - start > 5000) {
+        clearInterval(interval);
+        console.warn('[Client1] timeout waiting remote update; current:', current);
+        resolve();
+      }
+    }, 200);
+  });
+}
+main();

package/src/client2.ts

@@ -0,0 +1,18 @@
+import { getService, initializeClient, SetConfigItem } from './clientLib.js'
+import assert from 'node:assert/strict';
+async function main() {
+    await initializeClient('Client2');
+    const result = await getService('echo', 'testClient', ['hoi!!!!'])
+    console.log('[Client2] echo result:', result)
+    // Validate that configs registered by Client1 are visible and updated
+    const configs: any = await getService('getConfigs', 'tonpleun', []);
+    assert.ok(configs['testClient'], 'configs for testClient should exist');
+    assert.ok(configs['testClient']['conf:greeting'], 'conf:greeting should be present');
+    console.log('[Client2] observed config:', configs['testClient']['conf:greeting']);
+    // Trigger a remote config update for owner 'testClient' and verify server state
+    await SetConfigItem('conf:greeting', 'bye', 'testClient');
+    const configsAfterSet: any = await getService('getConfigs', 'tonpleun', []);
+    assert.equal(configsAfterSet['testClient']['conf:greeting'].value, 'bye');
+    console.log('[Client2] remote config update OK');
+}
+main();

package/src/clientLib.ts

@@ -0,0 +1,134 @@
+import WebSocket from 'ws';
+import { randomUUID } from 'crypto';
+import { requestType, stringPacketOptions, type getServicePacketClient, type GetServiceResponsePacketToServer, type GetServiceResponsePacketToClient, type InitPacket, type packet, type StringPacket, type registerConfigPacket, type setConfigPacket, type fakeTypeType } from './types.js';
+import { WsSend } from './helpers.js';
+
+const url = "ws://localhost:8765";
+export let ws: WebSocket;
+const serviceCallbacks = new Map<string, (...args: any[]) => any>();
+let clinetIDStore = "error";
+const localConfigs = new Map<string, registerConfigPacket>();
+
+export async function awaitServiceMessage(expectedFor: stringPacketOptions): Promise<StringPacket> {
+    return new Promise<StringPacket>((resolve) => {
+        const handler = (raw: Buffer) => {
+            const rawPacket = JSON.parse(raw.toString()) as packet;
+            if (rawPacket.type === requestType.Success) {
+                const data = rawPacket.data as StringPacket;
+                if (data.for === expectedFor) {
+                    ws.removeListener('message', handler);
+                    resolve(data);
+                }
+            }
+        };
+        ws.on('message', handler);
+    });
+}
+export async function registerConfigItem(name: string, description: string, value: string, idthing: string) {
+
+    WsSend(ws, { type: requestType.RegisterConifg, data: { name: name, description: description, defaultValue: value, type: typeof value, id: idthing } as registerConfigPacket })
+    // Wacht tot de verbinding is geopend
+    return new Promise<void>((resolve) => {
+        awaitServiceMessage(stringPacketOptions.registerConfigSuccess).then(() => {
+            localConfigs.set(idthing, { name, id: idthing, description, type: typeof value as fakeTypeType, defaultValue: value } as registerConfigPacket)
+            resolve();
+        });
+    });
+}
+export async function SetConfigItem(idthing: string, newValue: string, clientId?: string) {
+    WsSend(ws, { type: requestType.SetConfig, data: { ClientId: clientId || clinetIDStore, id: idthing, newValue: newValue } as setConfigPacket })
+    return new Promise<void>((resolve) => {
+        awaitServiceMessage(stringPacketOptions.setConfigSuccess).then(() => {
+            const existing = localConfigs.get(idthing);
+            if (existing) {
+                localConfigs.set(idthing, { ...existing, value: newValue } as registerConfigPacket);
+            }
+            resolve();
+        });
+    });
+}
+
+export async function registerService(ServiceId: string, args: fakeTypeType[], callback: (...args: any[]) => any) {
+    WsSend(ws, { type: requestType.RegisterService, data: { ServiceId, args } });
+    serviceCallbacks.set(ServiceId, callback);
+    return new Promise<void>((resolve) => {
+        awaitServiceMessage(stringPacketOptions.registerServiceSuccess).then(() => {
+            resolve();
+        });
+    });
+}
+export async function getService(ServiceId: string, ClientId: string, inputs: any[]): Promise<any> {
+    const connectionId = randomUUID();
+    WsSend(ws, { type: requestType.GetService, data: { ClientId, ServiceId, args: inputs, connectionId } as getServicePacketClient });
+    return new Promise<any>((resolve) => {
+        const handler = (raw: Buffer) => {
+            const rawPacket = JSON.parse(raw.toString()) as packet;
+            if (rawPacket.type === requestType.GetServiceResponse) {
+                const data = rawPacket.data as GetServiceResponsePacketToClient;
+                if (data.serviceId === ServiceId && data.connectionId === connectionId) {
+                    ws.removeListener('message', handler);
+                    resolve(data.result);
+                }
+            }
+        };
+        ws.on('message', handler);
+    });
+}
+
+export async function initializeClient(ClientId: string) {
+    clinetIDStore = ClientId;
+    ws = new WebSocket(url);
+
+    ws.on('open', () => {
+        console.log('Verbonden met tonpleun server.');
+        WsSend(ws, { type: requestType.Init, data: { ClientId } as InitPacket })
+
+    });
+    ws.on('close', () => {
+        console.log('Verbinding met tonpleun server gesloten.');
+    });
+    ws.on('error', (error) => {
+        console.error('Fout opgetreden:', error);
+        ws.close();
+    });
+    ws.on('message', (data) => {
+        const rawPacket = JSON.parse(data.toString()) as packet
+        if (rawPacket.type === requestType.GetService) {
+            const serviceData = rawPacket.data as getServicePacketClient;
+            const callback = serviceCallbacks.get(serviceData.ServiceId);
+            if (callback) {
+                try {
+                    const result = callback(...serviceData.args);
+                    WsSend(ws, {
+                        type: requestType.GetServiceResponse, data: {
+                            result: result,
+                            ServiceId: serviceData.ServiceId,
+                            connectionId: serviceData.connectionId,
+                        } as GetServiceResponsePacketToServer
+                    });
+                } catch (error) {
+                    console.error(`Fout bij uitvoeren van service ${serviceData.ServiceId}:`, error);
+                }
+            }
+
+        } else if (rawPacket.type === requestType.SetConfig) {
+            const cfg = rawPacket.data as setConfigPacket;
+            const existing = localConfigs.get(cfg.id);
+            if (existing) {
+                localConfigs.set(cfg.id, { ...existing, value: cfg.newValue } as registerConfigPacket);
+            }
+        }
+    });
+
+    // Wacht tot de verbinding is geopend
+    return new Promise<void>((resolve) => {
+        awaitServiceMessage(stringPacketOptions.initSuccess).then(() => {
+            resolve();
+        });
+    });
+}
+
+export function getConfigValue(id: string): any | undefined {
+    const item = localConfigs.get(id);
+    return item ? (item.value ?? item.defaultValue) : undefined;
+}

package/src/helpers.ts

@@ -0,0 +1,12 @@
+import type WebSocket from "ws";
+import { requestType, stringPacketOptions, type packet, type StringPacket } from "./types.js";
+export function log(id: any, ...args: any) {
+    // .toString() als je niet groen wil
+    console.log('[', id, ']', args);
+}
+export function WsSend(ws: WebSocket, data: packet) {
+    ws.send(JSON.stringify(data));
+}
+export function successPacketBuilder(msg: string, B: stringPacketOptions) {
+    return { type: requestType.Success, data: { msg: msg, for: B } as StringPacket } as packet
+}

package/src/server.ts

@@ -0,0 +1,125 @@
+import { log, successPacketBuilder, WsSend } from './helpers.js';
+import { WebSocketServer, WebSocket } from 'ws';
+import { requestType, stringPacketOptions, type args, type getServicePacket, type getServicePacketClient, type GetServiceResponsePacketToClient, type InitPacket, type packet, type registerConfigPacket, type RegisterServicePacket, type setConfigPacket } from './types.js';
+
+function mapToObject(map: Map<any, any>) {
+  return Object.fromEntries([...map.entries()].map(([kMaxLength, v]): any => [kMaxLength, v instanceof Map ? mapToObject(v) : v]))
+}
+
+let clients: Record<string, WebSocket> = {};
+let services = new Map<string, Map<string, args>>();
+let configs = new Map<string, Map<string, registerConfigPacket>>();
+let localServices = new Map<string, (...args: any[]) => any>();
+localServices.set('getServices', (...args: any[]) => { return mapToObject(services) })
+localServices.set('getConfigs', (...args: any[]) => { return mapToObject(configs) })
+// Map a unique connectionId to the original requester WebSocket
+const connectionMap = new Map<string, WebSocket>();
+const wsServer = new WebSocketServer({ host: '0.0.0.0', port: 8765 });
+wsServer.on('connection', (ws, req) => {
+  let id = req.socket.remoteAddress as string;
+  log(id, 'ws verbonden wachten op init.');
+
+  ws.on('message', async (raw) => {
+    const jsonData = JSON.parse(raw.toString()) as packet;
+    let data;
+    switch (jsonData.type) {
+      case requestType.Init:
+        data = jsonData.data as InitPacket;
+        clients[data.ClientId] = ws;
+        id = data.ClientId;
+        services.set(id, new Map())
+        // initialize per-client config store to avoid undefined access
+        configs.set(id, new Map())
+        log(id, 'ws init gedaan, client id gegeven. ip: ', req.socket.remoteAddress);
+        WsSend(ws, successPacketBuilder('init gedaan.', stringPacketOptions.initSuccess));
+        break;
+      case requestType.RegisterService:
+        data = jsonData.data as RegisterServicePacket;
+        services.get(id)!.set(data.ServiceId, data.args);
+        log(id, `service ${data.ServiceId} geregistreerd.`);
+        WsSend(ws, successPacketBuilder(`service ${data.ServiceId} geregistreerd.`, stringPacketOptions.registerServiceSuccess));
+        break;
+      case requestType.GetService:
+        data = jsonData.data as getServicePacket;
+        log(id, `service ${data.ServiceId} opgevraagd bij client ${data.ClientId}.`);
+        if (!(data.ClientId == "tonpleun")) {
+          const serviceOwnerWs = clients[data.ClientId];
+          if (serviceOwnerWs && services.get(data.ClientId)?.has(data.ServiceId)) {
+            // store mapping from this request's connectionId to the original requester
+            connectionMap.set(data.connectionId, ws);
+            WsSend(serviceOwnerWs, {
+              type: requestType.GetService,
+              data: {
+                ServiceId: data.ServiceId,
+                args: data.args,
+                connectionId: data.connectionId,
+              } as getServicePacketClient
+            });
+          } else {
+            log(id, `service ${data.ServiceId} niet gevonden voor client ${data.ClientId}.`);
+          }
+        } else {
+          const returnMe = localServices.get(data.ServiceId)!(data.args);
+          WsSend(ws, {
+            type: requestType.GetServiceResponse,
+            data: {
+              result: returnMe,
+              connectionId: data.connectionId,
+              serviceId: data.ServiceId
+            } as GetServiceResponsePacketToClient
+          })
+        }
+        break;
+      case requestType.GetServiceResponse:
+        data = jsonData.data;
+        log(id, `antwoord voor service ${data.ServiceId} ontvangen, doorsturen naar client.`);
+        const originalRequesterWs = connectionMap.get(data.connectionId);
+        if (originalRequesterWs) {
+          WsSend(originalRequesterWs, {
+            type: requestType.GetServiceResponse,
+            data: {
+              result: data.result,
+              serviceId: data.ServiceId,
+              connectionId: data.connectionId,
+            } as GetServiceResponsePacketToClient
+          });
+          connectionMap.delete(data.connectionId);
+        }
+        break;
+      case requestType.RegisterConifg:
+        data = jsonData.data as registerConfigPacket;
+        log(id, 'registeer een nieuwe config ityem');
+        // fuck het we slaan de hele packet op
+        configs.get(id)!.set(data.id, data);
+        WsSend(ws, successPacketBuilder('dinges', stringPacketOptions.registerConfigSuccess))
+        break;
+      case requestType.SetConfig:
+        data = jsonData.data as setConfigPacket;
+        log(id, 'update de dinges');
+        const otherGuy = clients[data.ClientId]
+        if (otherGuy) {
+          const prev = configs.get(data.ClientId)!.get(data.id) as registerConfigPacket;
+          configs.get(data.ClientId)!.set(
+            data.id,
+            { ...prev, value: data.newValue } as registerConfigPacket
+          )
+          WsSend(otherGuy, { type: requestType.SetConfig, data: data as setConfigPacket })
+        }
+        WsSend(ws, successPacketBuilder('dinges', stringPacketOptions.setConfigSuccess))
+
+        break;
+      default:
+        log(id, 'invalid msg');
+        break;
+    }
+  });
+
+  ws.on('close', () => {
+    services.delete(id);
+    log(id, 'ws gesloten.')
+  })
+
+});
+wsServer.on('listening', () => {
+  console.log('klaar voor clients.')
+})

package/src/types.ts

@@ -0,0 +1,73 @@
+export enum requestType {
+    Init,
+    Success,
+    Error,
+    RegisterService,
+    GetServiceResponse,
+    GetService,
+    RegisterConifg,
+    SetConfig
+}
+export enum stringPacketOptions { Error, initSuccess, registerServiceSuccess, getServiceSuccess, registerConfigSuccess, setConfigSuccess };
+export type fakeTypeType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export type packet = {
+    type: requestType,
+    data: any,
+}
+// requestType.Init
+export type InitPacket = {
+    ClientId: string,
+}
+// requestType.Success en requestType.Error
+export type StringPacket = {
+    msg: string,
+    for: stringPacketOptions
+}
+// requestType.RegisterService
+export type RegisterServicePacket = {
+    ServiceId: string,
+    args: fakeTypeType[]
+}
+// requestType.GetService ( client1 -> server)
+export type getServicePacket = {
+    ClientId: string,
+    ServiceId: string,
+    connectionId: string,
+    args: any[],
+}
+export type args = fakeTypeType[];
+// requestType.getService (server -> client2)
+export type getServicePacketClient = {
+    ServiceId: string,
+    args: any[],
+    connectionId: string,
+}
+// requestType.GetServiceResponse (client -> server)
+// client2 -> server
+export type GetServiceResponsePacketToServer = {
+    ServiceId: string,
+    result: any,
+    connectionId: string,
+}
+// requestType.GetServiceResponse (server -> client)
+// server -> client1
+export type GetServiceResponsePacketToClient = {
+    result: any,
+    serviceId: string,
+    connectionId: string,
+}
+// client -> server
+export type registerConfigPacket = {
+    name: string,
+    id: string,
+    description: string,
+    type: fakeTypeType,
+    defaultValue: any,
+    value?: any
+}
+// server -> client
+export type setConfigPacket = {
+    ClientId: string,
+    newValue: any,
+    id: string
+}

package/src/v1/client.ts

@@ -0,0 +1,20 @@
+import { config, configType, initializeClient, registerConfigItem, registerService } from "./lib.js";
+
+async function main() {
+
+    await initializeClient();
+
+    // Init onze services 
+    function serviceEcho(args: any[]): any {
+        if (config['echo']) {
+            console.log('Echo service aangeroepen met args:', args);
+        }
+        return args[0] || "ontvangen";
+    }
+
+    await registerService('test.echo', serviceEcho, ['message']);
+
+    await registerConfigItem('echo', 'gebruik echo', configType.bool, true);
+}
+
+main();

package/src/v1/lib.ts

@@ -0,0 +1,194 @@
+import WebSocket from 'ws';
+
+const url = "ws://localhost:8765";
+
+export type Message = {
+    status: string;
+    human_readable: string;
+    callbackId?: number;
+    serviceId?: string;
+    args?: any[];
+    data?: any;
+    id?: string;
+    value?: any;
+
+};
+
+export enum configType {
+    str,
+    bool,
+    int
+}
+
+export let config: Record<string, any> = {};
+// voor wie complete controle wil over ws client gedrag
+export let ws: WebSocket;
+
+export let successHandler: ((data: any) => void) | null = null;
+export let errorHandler: ((error: any) => void) | null = null;
+export let debugLogging: boolean = false;
+let serviceHandlers: Record<string, (args: any[]) => any> = {};
+let waitingForData: boolean = false;
+
+function debugLog(...message: any[]) {
+    if (debugLogging) {
+        console.log('[DEBUG]', message);
+    }
+}
+
+function parseData(msg: Message): any | null {
+    if (ws) {
+        if (msg.status === "200") {
+            debugLog('Ontvangen data:', msg.data);
+            if (successHandler && !waitingForData) successHandler(msg.data);
+        }
+        else if (msg.status === "210") {
+            if (waitingForData && successHandler) successHandler(msg.data)
+        }
+        else if (msg.status === '700') {
+            debugLog('Service oproep ontvangen:', msg.callbackId);
+            serviceHandlers[msg.serviceId || '']?.(msg.args || []);
+            ws.send(JSON.stringify({
+                action: 'response',
+                callbackId: msg.callbackId,
+                data: msg.args,
+            }));
+        }
+        else if (msg.status === "600") {
+            debugLog('config update ontvangen')
+            if (msg?.id) {
+                config[msg?.id] = msg?.value;
+            }
+        } else {
+            if (errorHandler) errorHandler(msg.data)
+            // console.log('error code', msg.status)
+        }
+    } else {
+        console.error('WebSocket is niet geïnitialiseerd.');
+    }
+}
+
+export function registerService(serviceId: string, handler: (args: any[]) => any, args?: string[]) {
+    if (ws) {
+        serviceHandlers[serviceId] = handler;
+
+        ws.send(JSON.stringify({
+            action: 'register',
+            service: serviceId,
+            args: args || [],
+        }));
+    } else {
+        console.error('WebSocket is niet geïnitialiseerd.');
+    }
+}
+export async function registerServiceAsync(serviceId: string, handler: (args: any[]) => any, args?: string[]): Promise<any> {
+    if (ws) {
+        return new Promise((resolve, reject) => {
+            successHandler = resolve;
+            errorHandler = reject;
+            ws.send(JSON.stringify({
+                action: 'get',
+                service: serviceId,
+                args: args,
+            }));
+        });
+    } else {
+        return Promise.reject('WebSocket is niet geïnitialiseerd.');
+    }
+}
+// met callback
+export function callService(serviceId: string, args: any[], onSuccess: (data: any) => void, onError: (error: any) => void) {
+    if (ws) {
+        successHandler = onSuccess;
+        errorHandler = onError;
+        waitingForData = true;
+        ws.send(JSON.stringify({
+            action: 'get',
+            service: serviceId,
+            args: args,
+        }));
+    } else {
+        console.error('WebSocket is niet geïnitialiseerd.');
+    }
+}
+// met promise
+export async function callServiceAsync(serviceId: string, args: any[]): Promise<any> {
+    if (ws) {
+        return new Promise((resolve, reject) => {
+            successHandler = resolve;
+            errorHandler = reject;
+            waitingForData = true;
+            ws.send(JSON.stringify({
+                action: 'get',
+                service: serviceId,
+                args: args,
+            }));
+        });
+    } else {
+        return Promise.reject('WebSocket is niet geïnitialiseerd.');
+    }
+}
+
+export async function registerConfigItem(id: string, human_name: string, configType: configType, value: any): Promise<any> {
+    if (ws) {
+        config[id] = value;
+        return new Promise((resolve, reject) => {
+            successHandler = resolve;
+            errorHandler = reject;
+            ws.send(JSON.stringify({
+                action: "makeConfigOption",
+                human: human_name,
+                id: id,
+                configType: configType,
+                value: value
+            }));
+        });
+    } else {
+        return Promise.reject('WebSocket is niet geïnitialiseerd.d')
+    }
+}
+export async function setConfigItem(id: string, value: any) {
+    if (ws) {
+        return new Promise((resolve, reject) => {
+            successHandler = resolve;
+            errorHandler = reject;
+            ws.send(JSON.stringify({
+                action: "makeConfigOption",
+                id: id,
+                value: value
+            }));
+        });
+
+    } else {
+        return Promise.reject('WebSocket is niet geïnitialiseerd.')
+    }
+}
+
+export async function initializeClient() {
+    ws = new WebSocket(url);
+
+    ws.on('open', () => {
+        debugLog('Verbonden met de server');
+        console.log('Verbonden met tonpleun server.');
+    });
+
+    ws.on('message', (data) => {
+        parseData(JSON.parse(data.toString()) as Message);
+    });
+
+    ws.on('close', () => {
+        debugLog('Verbinding gesloten');
+        console.log('Verbinding met tonpleun server gesloten.');
+    });
+
+    ws.on('error', (error) => {
+        console.error('Fout opgetreden:', error);
+    });
+
+    // Wacht tot de verbinding is geopend
+    return new Promise<void>((resolve) => {
+        ws.on('open', () => {
+            resolve();
+        });
+    });
+}

package/src/v1/main.ts

@@ -0,0 +1,224 @@
+import { WebSocketServer, WebSocket } from 'ws';
+
+type ServiceClient = 'BUILTIN' | WebSocket;
+
+type ServiceDef = {
+    id: string | number;
+    args: string[];
+    client: ServiceClient;
+    FUNC?: (args: any[]) => any | Promise<any>;
+};
+enum configType {
+    str,
+    bool,
+    int
+};
+type configOption = {
+    id: string;
+    human_name: string;
+    configType: configType
+    owner: ServiceClient;
+    value: any;
+};
+
+const clients = new Set<WebSocket>();
+
+function getServices(args: any[]): string[] {
+    return Object.keys(servicesAvailable);
+};
+
+let servicesAvailable: Record<string, ServiceDef> = {
+    'connector.status': {
+        id: 0,
+        args: [],
+        client: 'BUILTIN',
+    },
+    'connector.services': {
+        id: 1,
+        args: [],
+        client: 'BUILTIN',
+        FUNC: getServices,
+    },
+    'connector.echo': {
+        id: 2,
+        args: ['message'],
+        client: 'BUILTIN',
+        FUNC: (args: any[]) => args[0] || "ontvangen",
+    }
+};
+
+let configOptions: Record<string, configOption> = {};
+
+let awaitingResponses: Record<number, WebSocket> = {};
+
+const wss = new WebSocketServer({ host: '0.0.0.0', port: 8765 });
+
+wss.on('connection', (ws, req) => {
+    clients.add(ws);
+    console.log('Client verbonden:', req.socket.remoteAddress);
+
+    ws.on('message', async (raw) => {
+        const message = raw.toString();
+        console.log(`Ontvangen bericht van ${req.socket.remoteAddress}: ${message}`);
+
+        let data: any;
+        try {
+            data = JSON.parse(message);
+        } catch {
+            ws.send(JSON.stringify({ status: '400', human_readable: 'Ongeldige JSON' }));
+            return;
+        }
+
+        if (data?.action === 'get') {
+            const service = servicesAvailable[data?.service as string];
+
+            if (service) {
+                if (service.client === 'BUILTIN') {
+                    if (!service.FUNC) {
+                        ws.send(
+                            JSON.stringify({
+                                status: '200',
+                                human_readable: 'online, geen functie om uit te voeren.',
+                                data: null,
+                            }),
+                        );
+                    } else {
+                        try {
+                            const result = await Promise.resolve(service.FUNC(data?.args || []));
+                            ws.send(
+                                JSON.stringify({
+                                    status: '200',
+                                    human_readable: 'success',
+                                    data: result,
+                                }),
+                            );
+                        } catch {
+                            ws.send(
+                                JSON.stringify({
+                                    status: '500',
+                                    human_readable: 'Fout bij uitvoeren van service',
+                                }),
+                            );
+                        }
+                    }
+                } else {
+                    const id = Date.now();
+                    service.client.send(JSON.stringify({
+                        status: '700',
+                        human_readable: 'service call',
+                        args: data?.args || [],
+                        serviceId: service.id,
+                        callbackId: id,
+                    }));
+                    awaitingResponses[id] = ws;
+                    ws.send(JSON.stringify({
+                        status: '202',
+                        human_readable: 'Verzoek verzonden naar service client',
+                        calbackId: id,
+                    }));
+                }
+            } else {
+                ws.send(JSON.stringify({ status: '404', human_readable: 'Service niet gevonden' }));
+            }
+        }
+        else if (data?.action == "register") {
+            const newSerivice: ServiceDef = {
+                id: data?.service,
+                args: data?.args || [],
+                client: ws,
+            };
+            servicesAvailable[data?.service as string] = newSerivice;
+            ws.send(JSON.stringify({
+                status: '201',
+                human_readable: `Service ${data?.service} geregistreerd.`,
+                data: { serviceId: newSerivice.id },
+            }));
+
+        }
+        else if (data?.action == "response") {
+            const callbackId = data?.callbackId;
+            const responseData = data?.data;
+
+            const originalRequester = awaitingResponses[callbackId];
+            if (originalRequester) {
+                originalRequester.send(JSON.stringify({
+                    status: '210',
+                    human_readable: 'Response van service client',
+                    data: responseData,
+                }));
+                delete awaitingResponses[callbackId];
+            } else {
+                ws.send(JSON.stringify({
+                    status: '404',
+                    human_readable: 'Oorspronkelijke aanvrager niet gevonden voor deze callbackId',
+                }));
+            }
+
+        }
+        else if (data?.action === "getConfigOptions") {
+            ws.send(JSON.stringify({ status: "200", human_readable: "config data", data: configOptions }))
+        } else if (data?.action === "makeConfigOption") {
+            configOptions[data?.id] = {
+                id: data?.id,
+                human_name: data?.human,
+                owner: ws,
+                configType: data?.configType,
+                value: data?.value
+            }
+            ws.send(JSON.stringify({ status: '200', human_readable: "gemaakt!" }))
+        } else if (data?.action === "setConfig") {
+            if (data?.id && data?.value) {
+                let c = configOptions[data.id];
+                if (!(c)) {
+                    ws.send(JSON.stringify({
+                        status: '404',
+                        human_readable: 'config item niet gevonden',
+                    }));
+                } else {
+                    c.value = data.value;
+                    configOptions[data.id] = c;
+                    if (!(c.owner === "BUILTIN")) {
+                        c.owner.send(JSON.stringify({
+                            status: "600",
+                            id: data.id,
+                            value: data.value
+                        }))
+                    }
+                    ws.send(
+                        JSON.stringify(
+                            { status: "200", human_readable: "Config geupdate" }
+                        )
+                    )
+                }
+
+            } else {
+                ws.send(JSON.stringify({
+                    status: "400",
+                    human_readable: "je verzoek was niet goed"
+                }))
+            }
+        }
+    });
+
+    ws.on('close', () => {
+        // vewijder alles wat deze client heet geregistreerd
+        for (const [name, service] of Object.entries(servicesAvailable)) {
+            if (service.client === ws) {
+                delete servicesAvailable[name];
+                console.log(`Service ${name} verwijderd vanwege client disconnect.`);
+            }
+        }
+        for (const [name, service] of Object.entries(configOptions)) {
+            if (service.owner === ws) {
+                delete servicesAvailable[name];
+                console.log(`config ${name} verwijderd vanwege client disconnect.`);
+            }
+        }
+
+        clients.delete(ws);
+        console.log('Client weg');
+
+    });
+});
+
+console.log('Server draait op ws://localhost:8765');

package/src/v1/test2.ts

@@ -0,0 +1,14 @@
+import { initializeClient, callServiceAsync, setConfigItem } from "./lib.js";
+
+async function main() {
+    await initializeClient();
+
+    const test = await callServiceAsync('test.echo', ['Hallo van de client!'])
+    console.log('Antwoord van echo service (promise):', test);
+
+    await setConfigItem('echo', false)
+
+    const test2 = await callServiceAsync('test.echo', ['Hallo van de client!'])
+    console.log('Antwoord van echo service (promise):', test2);
+}
+main();

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}

package/webui/clientLib.js

@@ -0,0 +1,186 @@
+// Browser versie
+
+var requestType;
+(function (requestType) {
+    requestType[requestType["Init"] = 0] = "Init";
+    requestType[requestType["Success"] = 1] = "Success";
+    requestType[requestType["Error"] = 2] = "Error";
+    requestType[requestType["RegisterService"] = 3] = "RegisterService";
+    requestType[requestType["GetServiceResponse"] = 4] = "GetServiceResponse";
+    requestType[requestType["GetService"] = 5] = "GetService";
+    requestType[requestType["RegisterConifg"] = 6] = "RegisterConifg";
+    requestType[requestType["SetConfig"] = 7] = "SetConfig";
+})(requestType || (requestType = {}));
+
+var stringPacketOptions;
+(function (stringPacketOptions) {
+    stringPacketOptions[stringPacketOptions["Error"] = 0] = "Error";
+    stringPacketOptions[stringPacketOptions["initSuccess"] = 1] = "initSuccess";
+    stringPacketOptions[stringPacketOptions["registerServiceSuccess"] = 2] = "registerServiceSuccess";
+    stringPacketOptions[stringPacketOptions["getServiceSuccess"] = 3] = "getServiceSuccess";
+    stringPacketOptions[stringPacketOptions["registerConfigSuccess"] = 4] = "registerConfigSuccess";
+    stringPacketOptions[stringPacketOptions["setConfigSuccess"] = 5] = "setConfigSuccess";
+})(stringPacketOptions || (stringPacketOptions = {}));
+
+const url = "ws://localhost:8765";
+export let ws;
+const serviceCallbacks = new Map();
+const localConfigs = new Map();
+
+export async function awaitServiceMessage(expectedFor) {
+    return new Promise((resolve) => {
+        const handler = (event) => {
+            try {
+                const rawPacket = JSON.parse(event.data);
+                if (rawPacket.type === requestType.Success) {
+                    const data = rawPacket.data;
+                    if (data.for === expectedFor) {
+                        ws.removeEventListener('message', handler);
+                        resolve(data);
+                    }
+                }
+            } catch (e) {
+                // ignore malformed packets
+            }
+        };
+        ws.addEventListener('message', handler);
+    });
+}
+
+function WsSend(ws, data) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(data));
+    }
+}
+
+export async function registerService(ServiceId, args, callback) {
+    WsSend(ws, { type: requestType.RegisterService, data: { ServiceId, args } });
+    serviceCallbacks.set(ServiceId, callback);
+    return await awaitServiceMessage(stringPacketOptions.registerServiceSuccess);
+}
+
+export async function registerConfigItem(name, description, value, idthing) {
+    WsSend(ws, {
+        type: requestType.RegisterConifg,
+        data: {
+            name: name,
+            description: description,
+            defaultValue: value,
+            type: typeof value,
+            id: idthing
+        }
+    });
+    return await awaitServiceMessage(stringPacketOptions.registerConfigSuccess).then((msg) => {
+        localConfigs.set(idthing, {
+            name,
+            id: idthing,
+            description,
+            type: typeof value,
+            defaultValue: value
+        });
+        return msg;
+    });
+}
+
+export async function SetConfigItem(idthing, newValue, clientId) {
+    WsSend(ws, {
+        type: requestType.SetConfig,
+        data: {
+            ClientId: clientId,
+            id: idthing,
+            newValue: newValue
+        }
+    });
+    return await awaitServiceMessage(stringPacketOptions.setConfigSuccess).then((msg) => {
+        const existing = localConfigs.get(idthing);
+        if (existing) {
+            localConfigs.set(idthing, { ...existing, value: newValue });
+        }
+        return msg;
+    });
+}
+
+export async function getService(ServiceId, ClientId, inputs) {
+    const connectionId =
+        (typeof crypto !== 'undefined' && crypto.randomUUID)
+            ? crypto.randomUUID()
+            : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+
+    WsSend(ws, { type: requestType.GetService, data: { ClientId, ServiceId, args: inputs, connectionId } });
+
+    return new Promise((resolve) => {
+        const handler = (event) => {
+            try {
+                const rawPacket = JSON.parse(event.data);
+                if (rawPacket.type === requestType.GetServiceResponse) {
+                    const data = rawPacket.data;
+                    if (data.serviceId === ServiceId && data.connectionId === connectionId) {
+                        ws.removeEventListener('message', handler);
+                        resolve(data.result);
+                    }
+                }
+            } catch (e) {
+                // ignore malformed packets
+            }
+        };
+        ws.addEventListener('message', handler);
+    });
+}
+
+export async function initializeClient(ClientId) {
+    ws = new WebSocket(url);
+
+    ws.addEventListener('open', () => {
+        console.log('Verbonden met tonpleun server.');
+        WsSend(ws, { type: requestType.Init, data: { ClientId } });
+    });
+
+    ws.addEventListener('close', () => {
+        console.log('Verbinding met tonpleun server gesloten.');
+    });
+
+    ws.addEventListener('error', (event) => {
+        console.error('Fout opgetreden:', event);
+        try { ws.close(); } catch { }
+    });
+
+    ws.addEventListener('message', async (event) => {
+        try {
+            const rawPacket = JSON.parse(event.data);
+            if (rawPacket.type === requestType.GetService) {
+                const serviceData = rawPacket.data;
+                const callback = serviceCallbacks.get(serviceData.ServiceId);
+                if (callback) {
+                    try {
+                        const result = await Promise.resolve(callback(...serviceData.args));
+                        WsSend(ws, {
+                            type: requestType.GetServiceResponse,
+                            data: {
+                                result,
+                                ServiceId: serviceData.ServiceId,
+                                connectionId: serviceData.connectionId,
+                            }
+                        });
+                    } catch (error) {
+                        console.error(`Fout bij uitvoeren van service ${serviceData.ServiceId}:`, error);
+                    }
+                }
+            } else if (rawPacket.type === requestType.SetConfig) {
+                const cfg = rawPacket.data;
+                const existing = localConfigs.get(cfg.id);
+                if (existing) {
+                    localConfigs.set(cfg.id, { ...existing, value: cfg.newValue });
+                }
+            }
+        } catch (e) {
+            // ignore malformed packets
+        }
+    });
+
+    return await awaitServiceMessage(stringPacketOptions.initSuccess);
+}
+
+export function getConfigValue(id) {
+    const item = localConfigs.get(id);
+    return item ? (item.value ?? item.defaultValue) : undefined;
+}

package/webui/index.html

@@ -0,0 +1,22 @@
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tonpleun webui</title>
+    <script type="module" src="main.js"></script>
+</head>
+
+<body id="out">
+    <div id="buttonList">
+    </div>
+    <div id="container"></div>
+    <script>function onchangeOfthing(newValue) {
+            const container = document.getElementById('container');
+            const localdata = window.dataMap.get(newValue);
+            container.innerText = JSON.stringify(localdata);
+        }</script>
+
+</body>
+
+</html>

package/webui/main.js

@@ -0,0 +1,22 @@
+import { getService, initializeClient } from "./clientLib.js";
+async function main() {
+    await initializeClient('webUI');
+    getData();
+    setInterval(getData, 1000);
+}
+async function getData() {
+    const data = await getService('getConfigs', 'tonpleun', []);
+    console.log('data update')
+    window.tonpleunData = data;
+    update(window.tonpleunData);
+
+}
+function update(data) {
+    window.dataMap = new Map(Object.entries(data));
+    document.getElementById('buttonList').innerHTML = '';
+    window.dataMap.forEach((dinges, name) => {
+        console.log(name, dinges);
+        document.getElementById('buttonList').innerHTML += '<button onclick="onchangeOfthing(\'' + name + '\')">' + name + '</button>';
+    });
+}
+main();