@cryptforge/key-exchange 0.1.0

package/dist/server.mjs

@@ -0,0 +1,902 @@
+// src/server/useKeyExchangeServer.ts
+import DHT from "hyperdht";
+import b4a2 from "b4a";
+
+// src/server/messages.ts
+import b4a from "b4a";
+
+// src/types/messages.ts
+var MESSAGES = {
+  enableBroadcast: "admin:broadcast:enable",
+  connect: "client:topic:connect",
+  onClientConnection: "admin:topic:connected",
+  requestKeystore: "client:keystore:request",
+  onKeystoreRequestInvalidPIN: "admin:pin:invalid",
+  onKeystoreRequestValidPIN: "admin:pin:valid",
+  onKeystoreRequest: "admin:request:received",
+  approveRequest: "admin:request:approve",
+  onClientApproval: "client:request:approved",
+  denyRequest: "admin:request:deny",
+  onClientDenial: "client:request:denied",
+  onCompletion: "server:link:complete",
+  disableBroadcast: "admin:broadcast:disable",
+  onBroadcastDisable: "client:broadcast:disabled",
+  getDeviceInfo: "client:request:deviceInfo",
+  getHostname: "client:request:hostname",
+  // Presence/Network messages
+  connectPresence: "network:connect",
+  broadcastClientState: "network:broadcast",
+  onClientStateRequest: "network:request",
+  onClientStateUpdate: "network:update"
+};
+
+// src/server/messages.ts
+var syncSetupEventRoutes = {
+  onClientConnection: MESSAGES.onClientConnection,
+  onKeystoreRequest: MESSAGES.onKeystoreRequest,
+  onClientApproval: MESSAGES.onClientApproval,
+  onClientDenial: MESSAGES.onClientDenial,
+  onCompletion: MESSAGES.onCompletion,
+  onBroadcastDisable: MESSAGES.onBroadcastDisable,
+  onKeystoreRequestInvalidPIN: MESSAGES.onKeystoreRequestInvalidPIN,
+  onKeystoreRequestValidPIN: MESSAGES.onKeystoreRequestValidPIN
+};
+var requestHeaders = [
+  {
+    code: 1e3,
+    name: "Request PIN",
+    description: "The Client is asking the Server to show UI of a PIN screen for the user to enter on the Client"
+  },
+  {
+    code: 2e3,
+    name: "Request Keystore",
+    description: "The Client is asking the Server to show UI for the user to approve or reject the request"
+  }
+];
+var sendRequest = async (options) => {
+  const index = requestHeaders.findIndex(
+    (response) => response.name === options.header
+  );
+  if (index !== -1) {
+    const header = requestHeaders[index];
+    const body = options.body();
+    const request = {
+      header,
+      body
+    };
+    const payload = JSON.stringify(request);
+    for (const socket of options.to) {
+      console.log(
+        `hyperswarm: sending ${header.name} to connection ${b4a.toString(
+          socket.remotePublicKey,
+          "hex"
+        )}`
+      );
+      socket.write(payload);
+    }
+  } else {
+    console.log(`Request with name \`${options.header}\` not found`);
+  }
+};
+var responseHeaders = [
+  {
+    code: 1501,
+    name: "Connection Failure: Broadcast disabled",
+    type: "Failure"
+  },
+  { code: 2200, name: "Authentication Succeeded", type: "Success" },
+  { code: 2400, name: "Authentication Error: Invalid PIN", type: "Error" },
+  { code: 3200, name: "Transmition Succeeded: Approved", type: "Success" },
+  { code: 3201, name: "Transmition Succeeded: Rejected", type: "Success" },
+  { code: 4200, name: "Setup Succeeded", type: "Success" }
+];
+var sendResponse = (options) => {
+  const index = responseHeaders.findIndex(
+    (response) => response.name === options.header
+  );
+  if (index !== -1) {
+    const header = responseHeaders[index];
+    const data = options.body();
+    const response = {
+      header,
+      body: data
+    };
+    const payload = JSON.stringify(response);
+    for (const socket of options.to) {
+      console.log(
+        `hyperswarm: sending ${header.name} to connection ${b4a.toString(
+          socket.remotePublicKey,
+          "hex"
+        )}`
+      );
+      socket.write(payload);
+    }
+  } else {
+    console.log(`Response with name \`${options.header}\` not found`);
+  }
+};
+
+// src/server/useKeyExchangeServer.ts
+function useKeyExchangeServer(onEvent) {
+  let client;
+  let dht;
+  const keyPair = DHT.keyPair();
+  const getKey = () => {
+    return b4a2.toString(keyPair.publicKey, "hex");
+  };
+  const generateRandomPIN = () => {
+    return Math.floor(1e5 + Math.random() * 9e5);
+  };
+  const pin = generateRandomPIN();
+  const getPIN = () => {
+    return `${pin}`;
+  };
+  let server;
+  const createServer = async () => {
+    dht = new DHT();
+    server = await dht.createServer((socket) => {
+      const name = b4a2.toString(socket.remotePublicKey, "hex");
+      console.log(`server: got a connection on \`${name}\``);
+      socket.on("data", (data) => {
+        parseRequest(data);
+      });
+      socket.on("error", (error) => {
+        onConnectionError(error);
+      });
+      client = socket;
+    });
+  };
+  const parseRequest = (data) => {
+    console.log(`server: got data: ${data}`);
+    const parsedData = JSON.parse(data);
+    const payload = parsedData;
+    console.log("payload");
+    console.log(payload);
+    switch (payload.header.name) {
+      case "Request PIN":
+        onRequestPin(payload.body);
+        break;
+      case "Request Keystore":
+        onRequestKeystore(payload.body);
+        break;
+    }
+  };
+  const onConnectionError = (error) => {
+    console.log(`server: Connection error: ${error}`);
+  };
+  const onRequestPin = (body) => {
+    const route = syncSetupEventRoutes["onClientConnection"];
+    onEvent({
+      route,
+      data: {
+        pin: getPIN(),
+        name: body.deviceName,
+        app: body.appName
+      }
+    });
+  };
+  const onRequestKeystore = (body) => {
+    const pin2 = body.pin;
+    if (pin2 !== getPIN()) {
+      sendResponse({
+        to: [client],
+        header: "Authentication Error: Invalid PIN",
+        body: () => {
+          return {};
+        }
+      });
+      return;
+    } else {
+      sendResponse({
+        to: [client],
+        header: "Authentication Succeeded",
+        body: () => {
+          return {};
+        }
+      });
+    }
+    const route = syncSetupEventRoutes["onKeystoreRequest"];
+    onEvent({
+      route,
+      data: {}
+    });
+  };
+  const onRequestDenied = () => {
+    const route = syncSetupEventRoutes["onClientDenial"];
+    onEvent({ route, data: {} });
+  };
+  const onSetupComplete = () => {
+    const route = syncSetupEventRoutes["onCompletion"];
+    onEvent({ route, data: {} });
+  };
+  const beginBroadcast = async () => {
+    await createServer();
+    await server.listen(keyPair);
+    await server.refresh();
+    console.log(`server: opened connection to ${getKey()}`);
+  };
+  const endBroadcast = async () => {
+    if (server) {
+      await server.close();
+      console.log(`server: closed connection to ${getKey()}`);
+    }
+    if (dht) {
+      await dht.destroy();
+      console.log(`server: destroyed dht`);
+    }
+  };
+  const approveRequest = async (identity, appId) => {
+    sendResponse({
+      to: [client],
+      header: "Transmition Succeeded: Approved",
+      body: () => {
+        return {
+          identity,
+          appId
+        };
+      }
+    });
+  };
+  const completeSetupSuccess = async () => {
+    console.log("sending compltion message to client");
+    sendResponse({
+      to: [client],
+      header: "Setup Succeeded",
+      body: () => {
+        return {};
+      }
+    });
+    onSetupComplete();
+  };
+  const rejectRequest = async () => {
+    sendResponse({
+      to: [client],
+      header: "Transmition Succeeded: Rejected",
+      body: () => {
+        return {};
+      }
+    });
+    onRequestDenied();
+  };
+  const broadcastDisabled = async () => {
+    if (client) {
+      sendResponse({
+        to: [client],
+        header: "Connection Failure: Broadcast disabled",
+        body: () => {
+          return {};
+        }
+      });
+    }
+  };
+  return {
+    getKey,
+    getPIN,
+    beginBroadcast,
+    endBroadcast,
+    approveRequest,
+    completeSetupSuccess,
+    rejectRequest,
+    broadcastDisabled
+  };
+}
+
+// src/server/keyTransportServer.ts
+import WebSocket, { WebSocketServer } from "ws";
+
+// src/useNetworkPresenceServer.ts
+import Hyperswarm from "hyperswarm";
+import b4a3 from "b4a";
+function useNetworkPresence(onUpdate, onRequest) {
+  const deviceIDs = /* @__PURE__ */ new Map();
+  const swarm = new Hyperswarm();
+  swarm.on("connection", (connection) => {
+    const name = b4a3.toString(connection.remotePublicKey, "hex");
+    console.log("Presence: * got a connection from:", name, "*");
+    connections.push(connection);
+    sendStateRequestMessage(connection);
+    connection.once("close", () => {
+      console.log(
+        `Presence: Connection closed.  Removing connection ${b4a3.toString(
+          connection.remotePublicKey,
+          "hex"
+        )}`
+      );
+      connections.splice(connections.indexOf(connection), 1);
+      const id = deviceIDs.get(b4a3.toString(connection.remotePublicKey, "hex"));
+      if (id) {
+        broadcastStatusMessage(id, "unknown");
+      }
+      deviceIDs.delete(b4a3.toString(connection.remotePublicKey, "hex"));
+    });
+    connection.on("data", (data) => {
+      let parsedData;
+      try {
+        parsedData = JSON.parse(data);
+      } catch (error) {
+        console.error("Error parsing data:", error);
+        return;
+      }
+      const header = parsedData;
+      console.log(
+        "Presence: got data for ",
+        connection.publicKey.toString("hex")
+      );
+      if (header.type === "update") {
+        const payload = parsedData;
+        onUpdate({ id: payload.id, state: payload.state });
+        deviceIDs.set(
+          b4a3.toString(connection.remotePublicKey, "hex"),
+          payload.id
+        );
+      } else if (header.type === "request") {
+        onRequest();
+      }
+    });
+    connection.on("error", (error) => {
+      console.error(
+        `Presence: Connection error on connection ${b4a3.toString(
+          connection.remotePublicKey,
+          "hex"
+        )}: ${error}`
+      );
+    });
+  });
+  const connections = [];
+  const connect = async (topic, id) => {
+    console.log("Presence: connecting to topic: ", topic);
+    const key = b4a3.from(topic, "hex");
+    console.log("key: ", key);
+    const discovery = swarm.join(key, { client: true, server: true });
+    console.log("got discovery:  ");
+    const publicKey = b4a3.toString(
+      discovery.swarm.keyPair?.publicKey || discovery.swarm.publicKey || Buffer.alloc(32),
+      "hex"
+    );
+    console.log("Presence: public key is ", publicKey);
+    deviceIDs.set(publicKey, id);
+    discovery.flushed().then(() => {
+      console.log("Presence: joined topic:", b4a3.toString(key, "hex"));
+    });
+  };
+  const sendStateRequestMessage = async (connection) => {
+    const message = {
+      type: "request"
+    };
+    const payload = JSON.stringify(message);
+    console.log(
+      "sending state request message to: ",
+      connection.publicKey.toString("hex")
+    );
+    connection.write(payload);
+  };
+  const receiveStatusMessage = async (id, state) => {
+    return broadcastStatusMessage(id, state);
+  };
+  const broadcastStatusMessage = (id, state) => {
+    console.log(`server got connection state message for ${id}: `, state);
+    const message = {
+      type: "update",
+      id,
+      state
+    };
+    console.log("active connections: ", connections.length);
+    const payload = JSON.stringify(message);
+    for (const connection of connections) {
+      console.log("sending message to: ", connection.publicKey.toString("hex"));
+      connection.write(payload);
+    }
+    onUpdate(message);
+  };
+  return {
+    connect,
+    receiveStatusMessage
+  };
+}
+
+// src/client/useKeyExchangeClient.ts
+import DHT2 from "hyperdht";
+import b4a4 from "b4a";
+function useKeyExchangeClient(onEvent) {
+  let socket;
+  let deviceName;
+  let appName;
+  const connect = async (options) => {
+    deviceName = options.name;
+    appName = options.app;
+    return new Promise((resolve) => {
+      console.log(`client: connecting to server on ${options.key}`);
+      const publicKey = b4a4.from(options.key, "hex");
+      const dht = new DHT2();
+      socket = dht.connect(publicKey);
+      socket.once("open", () => {
+        const name = b4a4.toString(socket.remotePublicKey, "hex");
+        console.log(`client: got a connection on ${name}`);
+        resolve();
+      });
+      socket.on("data", (data) => {
+        parseResponse(data);
+      });
+      socket.on("error", (error) => {
+        onConnectionError(error);
+      });
+    });
+  };
+  const parseResponse = async (data) => {
+    console.log(`client: got data: ${data}`);
+    const parsedData = JSON.parse(data);
+    const payload = parsedData;
+    console.log("payload");
+    console.log(payload);
+    switch (payload.header.name) {
+      case "Connection Failure: Broadcast disabled":
+        onEvent({
+          route: syncSetupEventRoutes["onBroadcastDisable"],
+          data: {}
+        });
+        break;
+      case "Transmition Succeeded: Approved":
+        const identity = payload.body.identity;
+        const appId = payload.body.appId;
+        onEvent({
+          route: syncSetupEventRoutes["onClientApproval"],
+          data: { identity, appId }
+        });
+        break;
+      case "Transmition Succeeded: Rejected":
+        onEvent({ route: syncSetupEventRoutes["onClientDenial"], data: {} });
+        break;
+      case "Setup Succeeded":
+        onEvent({ route: syncSetupEventRoutes["onCompletion"], data: {} });
+        break;
+      case "Authentication Error: Invalid PIN":
+        onEvent({
+          route: syncSetupEventRoutes["onKeystoreRequestInvalidPIN"],
+          data: {
+            reason: "Invalid PIN Entered"
+          }
+        });
+        break;
+      case "Authentication Succeeded":
+        onEvent({
+          route: syncSetupEventRoutes["onKeystoreRequestValidPIN"],
+          data: {}
+        });
+        break;
+      default:
+        console.error(`error: response ${payload} not handled in client`);
+        break;
+    }
+  };
+  const onConnectionError = async (error) => {
+    console.log(`client: Connection error: ${error}`);
+    const route = syncSetupEventRoutes["onBroadcastDisable"];
+    switch (error.code) {
+      case "PEER_NOT_FOUND":
+        onEvent({
+          route,
+          data: {
+            title: "Peer Not Found",
+            description: "Another device with the specified broadcast key could not be located."
+          }
+        });
+        break;
+      default:
+        onEvent({
+          route,
+          data: {
+            title: "Client Disconnected",
+            description: "The connection to your other device was lost.  Please ensure you have another device that is broadcasting"
+          }
+        });
+        break;
+    }
+  };
+  const requestPIN = async () => {
+    await sendRequest({
+      to: [socket],
+      header: "Request PIN",
+      body: () => {
+        return { deviceName, appName };
+      }
+    });
+  };
+  const requestKeystore = async (pin) => {
+    await sendRequest({
+      to: [socket],
+      header: "Request Keystore",
+      body: () => {
+        return {
+          pin
+        };
+      }
+    });
+    const route = syncSetupEventRoutes["onKeystoreRequest"];
+    onEvent({ route, data: {} });
+  };
+  return {
+    connect,
+    requestPIN,
+    requestKeystore
+  };
+}
+
+// src/CoreTransportLogic.ts
+import crypto from "crypto";
+import os from "os";
+import si from "systeminformation";
+var CoreTransportLogic = class {
+  syncServer;
+  syncClient;
+  presence;
+  deviceInfo = null;
+  handleEvent;
+  presenceConnected = false;
+  constructor(handleEvent = () => {
+  }) {
+    this.handleEvent = handleEvent;
+    this.syncServer = useKeyExchangeServer(this.handleEvent);
+    this.syncClient = useKeyExchangeClient(this.handleEvent);
+    this.presence = useNetworkPresence(
+      this.onStateUpdate.bind(this),
+      this.onStateRequest.bind(this)
+    );
+    this.initializeDeviceInfo();
+  }
+  async initializeDeviceInfo() {
+    this.deviceInfo = await this.getDeviceInfo();
+  }
+  onStateUpdate(response) {
+    console.log("received state message for:", response.id);
+    this.handleEvent({ route: MESSAGES.onClientStateUpdate, data: response });
+  }
+  onStateRequest() {
+    console.log("received state request");
+    this.handleEvent({ route: MESSAGES.onClientStateRequest, data: {} });
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // Sync methods
+  async enableBroadcast() {
+    console.log(`admin: enabled broadcast`);
+    try {
+      await this.syncServer.beginBroadcast();
+      return this.syncServer.getKey();
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : "UNKNOWN";
+      console.error("Error on broadcast enable during topic sync setup:", code);
+      if (code === "ALREADY_LISTENING") {
+        return this.syncServer.getKey();
+      }
+      throw error;
+    }
+  }
+  async connect(topic, name, app) {
+    console.log(`client: requested connection to ${topic}`);
+    try {
+      await this.syncClient.connect({ key: topic, name, app });
+      await this.syncClient.requestPIN();
+    } catch (error) {
+      console.error("Error on topic connect during sync setup:", error);
+      throw error;
+    }
+  }
+  async requestKeystore(pin) {
+    console.log(`client: requested keystore using pin \`${pin}\``);
+    try {
+      await this.syncClient.requestKeystore(pin);
+    } catch (error) {
+      console.error("Error on keystore request during sync setup:", error);
+      throw error;
+    }
+  }
+  async approveRequest(data) {
+    console.log(`admin: request approved`);
+    try {
+      await this.syncServer.approveRequest(data.identity, data.appId);
+      await this.delay(3e3);
+      await this.syncServer.completeSetupSuccess();
+    } catch (error) {
+      console.error("Error on request approve during sync setup:", error);
+      throw error;
+    }
+  }
+  async denyRequest() {
+    console.log(`admin: request denied`);
+    try {
+      await this.syncServer.rejectRequest();
+    } catch (error) {
+      console.error("Error on request deny during sync setup:", error);
+      throw error;
+    }
+  }
+  async disableBroadcast() {
+    try {
+      await this.syncServer.endBroadcast();
+      await this.syncServer.broadcastDisabled();
+    } catch (error) {
+      console.error("Error on broadcast disable during sync setup:", error);
+      throw error;
+    }
+  }
+  // Device methods
+  async getDeviceInfo() {
+    if (this.deviceInfo) {
+      return this.deviceInfo;
+    }
+    const hostname = os.hostname();
+    const osInfo = await si.osInfo();
+    const uuid = await si.uuid();
+    const serial = osInfo.serial;
+    const distro = osInfo.distro;
+    const arch = osInfo.arch;
+    const hardwareUUID = uuid.hardware;
+    const key = serial + distro + arch + hardwareUUID;
+    const hash = crypto.createHash("sha256").update(key).digest("hex");
+    return { id: hash, name: hostname };
+  }
+  async getHostname() {
+    return os.hostname();
+  }
+  // Network methods
+  async connectPresence(topic) {
+    if (this.presenceConnected) {
+      console.log("Presence already connected, skipping");
+      return;
+    }
+    const deviceInfo = await this.getDeviceInfo();
+    const topicHash = crypto.createHash("sha256").update(topic).digest("hex");
+    console.log(`Connecting presence network to topic: ${topicHash}`);
+    await this.presence.connect(topicHash, deviceInfo.id);
+    this.presenceConnected = true;
+  }
+  broadcastClientState(id, state) {
+    this.presence.receiveStatusMessage(id, state);
+  }
+};
+
+// src/server/keyTransportServer.ts
+var KeyTransportServer = class {
+  wss;
+  activeConnections = /* @__PURE__ */ new Set();
+  core;
+  port;
+  logger;
+  constructor(config) {
+    this.port = config.port || 3001;
+    this.logger = config.logger || console;
+    this.wss = new WebSocketServer({ port: this.port });
+    this.core = new CoreTransportLogic(this.handleEvent);
+    this.setupServerHandlers();
+    this.logger.log(
+      `\u{1F680} CryptForge WebSocket Server running on ws://localhost:${this.port}`
+    );
+  }
+  // Event handler for CoreTransportLogic
+  handleEvent = (options) => {
+    this.logger?.log(
+      `Core event with route: \`${options.route}\` data:`,
+      options.data
+    );
+    this.broadcastEvent(options.route, options.data);
+  };
+  // Helper function to send a response
+  sendResponse = (ws, type, requestId, data, error) => {
+    const response = {
+      type,
+      requestId,
+      ...data && { data },
+      ...error && { error }
+    };
+    ws.send(JSON.stringify(response));
+    this.logger?.log("\u{1F4E4} Sent response:", response);
+  };
+  // Helper function to broadcast events to all connected clients
+  broadcastEvent = (route, data) => {
+    const message = JSON.stringify({
+      type: route,
+      data
+    });
+    this.activeConnections.forEach((ws) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(message);
+      }
+    });
+    this.logger?.log(`\u{1F4E1} Broadcast event: ${route}`, data);
+  };
+  setupServerHandlers = () => {
+    this.wss.on("connection", (ws) => {
+      this.logger?.log("\u2705 Client connected");
+      this.activeConnections.add(ws);
+      ws.on("message", async (data) => {
+        await this.handleMessage(ws, data);
+      });
+      ws.on("close", () => {
+        this.logger?.log("\u{1F44B} Client disconnected");
+        this.activeConnections.delete(ws);
+      });
+      ws.on("error", (error) => {
+        this.logger?.error("\u274C WebSocket error:", error);
+        this.activeConnections.delete(ws);
+      });
+    });
+    this.wss.on("error", (error) => {
+      this.logger?.error("\u274C Server error:", error);
+    });
+  };
+  handleMessage = async (ws, data) => {
+    try {
+      const message = JSON.parse(data.toString());
+      this.logger?.log("\u{1F4E8} Received:", message);
+      const { type, requestId, data: requestData } = message;
+      switch (type) {
+        // Sync messages
+        case MESSAGES.enableBroadcast:
+          this.logger?.log("\u{1F4E1} Enabling broadcast...");
+          try {
+            const broadcastId = await this.core.enableBroadcast();
+            this.sendResponse(ws, type, requestId, { broadcastId });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.connect:
+          this.logger?.log("\u{1F50C} Connecting to topic...");
+          try {
+            await this.core.connect(
+              requestData.topic,
+              requestData.name,
+              requestData.app
+            );
+            this.sendResponse(ws, type, requestId, {
+              connected: true,
+              topic: requestData.topic,
+              name: requestData.name,
+              app: requestData.app
+            });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.requestKeystore:
+          this.logger?.log("\u{1F4E8} Requesting keystore...");
+          try {
+            await this.core.requestKeystore(requestData.pin);
+            this.sendResponse(ws, type, requestId, {
+              requested: true,
+              pin: requestData.pin
+            });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.approveRequest:
+          this.logger?.log("\u2705 Approving request...");
+          try {
+            await this.core.approveRequest({
+              identity: requestData.identity,
+              appId: requestData.appId
+            });
+            this.sendResponse(ws, type, requestId, {
+              approved: true
+            });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.denyRequest:
+          this.logger?.log("\u274C Denying request...");
+          try {
+            await this.core.denyRequest();
+            this.sendResponse(ws, type, requestId, {
+              denied: true
+            });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.disableBroadcast:
+          this.logger?.log("\u{1F4F4} Disabling broadcast...");
+          try {
+            await this.core.disableBroadcast();
+            this.sendResponse(ws, type, requestId, {
+              disabled: true
+            });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.getDeviceInfo:
+          this.logger?.log("\u{1F50D} Getting device info...");
+          try {
+            const deviceInfo = await this.core.getDeviceInfo();
+            this.sendResponse(ws, type, requestId, deviceInfo);
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.getHostname:
+          this.logger?.log("\u{1F50D} Getting hostname...");
+          try {
+            const hostname = await this.core.getHostname();
+            this.sendResponse(ws, type, requestId, { hostname });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.connectPresence:
+          this.logger?.log("\u{1F50C} Connecting presence network...");
+          try {
+            await this.core.connectPresence(requestData.topic);
+            this.sendResponse(ws, type, requestId, { success: true });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        case MESSAGES.broadcastClientState:
+          this.logger?.log("\u{1F4E1} Broadcasting client state...");
+          try {
+            this.core.broadcastClientState(requestData.id, requestData.state);
+            this.sendResponse(ws, type, requestId, { success: true });
+          } catch (error) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: error instanceof Error ? error.message : "Unknown error"
+            });
+          }
+          break;
+        default:
+          this.logger?.log(`\u26A0\uFE0F  Unknown message type: ${type}`);
+          if (requestId) {
+            this.sendResponse(ws, type, requestId, null, {
+              message: `Unknown message type: ${type}`
+            });
+          }
+      }
+    } catch (error) {
+      this.logger?.error("\u274C Error processing message:", error);
+      try {
+        const parsed = JSON.parse(data.toString());
+        if (parsed.requestId) {
+          this.sendResponse(ws, parsed.type, parsed.requestId, null, {
+            message: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      } catch (e) {
+        this.logger?.error("\u274C Could not send error response:", e);
+      }
+    }
+  };
+  // Public methods for managing the server
+  close = (callback) => {
+    this.wss.close(callback);
+  };
+  getActiveConnections = () => {
+    return new Set(this.activeConnections);
+  };
+  getPort = () => {
+    return this.port;
+  };
+};
+export {
+  KeyTransportServer,
+  useKeyExchangeServer
+};