@cryptforge/key-exchange 0.1.0

package/dist/index.mjs

@@ -0,0 +1,572 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../../node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// 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"
+};
+
+// ../../node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+var eventemitter3_default = import_index.default;
+
+// src/client/keyTransportClient.ts
+var KeyTransportClient = class {
+  emitter;
+  ws = null;
+  serverUrl;
+  pendingRequests = /* @__PURE__ */ new Map();
+  requestTimeout = 3e4;
+  // 30 seconds default timeout
+  requestCounter = 0;
+  connectionPromise = null;
+  connectionResolver = null;
+  peers = /* @__PURE__ */ new Map();
+  constructor(serverUrl = "ws://localhost:3001") {
+    this.emitter = new eventemitter3_default();
+    this.serverUrl = serverUrl;
+    this.connectionPromise = this.connectWebSocket();
+  }
+  connectWebSocket() {
+    console.log(`\u{1F50C} Connecting to ${this.serverUrl}...`);
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.serverUrl);
+      this.connectionResolver = resolve;
+      const connectionTimeout = setTimeout(() => {
+        reject(new Error("Connection timeout"));
+        this.ws?.close();
+      }, 1e4);
+      this.ws.onopen = () => {
+        clearTimeout(connectionTimeout);
+        console.log("\u2705 Connected to CryptForge server");
+        resolve();
+        this.connectionResolver = null;
+      };
+      this.ws.onerror = (error) => {
+        clearTimeout(connectionTimeout);
+        console.error("\u274C WebSocket error:", error);
+        reject(new Error("WebSocket connection failed"));
+        this.rejectAllPendingRequests(new Error("WebSocket connection error"));
+      };
+      this.ws.onmessage = (event) => {
+        const message = JSON.parse(event.data);
+        if (message.requestId && this.pendingRequests.has(message.requestId)) {
+          this.handleRequestResponse(message);
+        } else {
+          this.receiveMessage(message.type, message.data);
+        }
+      };
+      this.ws.onclose = () => {
+        console.log("\u{1F44B} Disconnected from server");
+        this.rejectAllPendingRequests(new Error("WebSocket connection closed"));
+      };
+    });
+  }
+  generateRequestId = () => {
+    return `${Date.now()}-${++this.requestCounter}`;
+  };
+  handleRequestResponse = (message) => {
+    const requestId = message.requestId;
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingRequests.delete(requestId);
+    if (message.error) {
+      console.error(`\u274C Request ${requestId} failed:`, message.error);
+      pending.reject(new Error(message.error.message || "Request failed"));
+    } else {
+      console.log(`\u2705 Request ${requestId} succeeded:`, message.data);
+      pending.resolve(message.data);
+    }
+  };
+  rejectAllPendingRequests = (error) => {
+    this.pendingRequests.forEach((pending) => {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    });
+    this.pendingRequests.clear();
+  };
+  /**
+   * Send a request and wait for response
+   */
+  sendRequest = async (type, data, timeoutMs) => {
+    if (this.connectionPromise) {
+      await this.connectionPromise;
+    }
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket not connected");
+    }
+    const requestId = this.generateRequestId();
+    const timeout = timeoutMs || this.requestTimeout;
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error(`Request ${type} timed out after ${timeout}ms`));
+      }, timeout);
+      this.pendingRequests.set(requestId, {
+        resolve,
+        reject,
+        timeout: timeoutHandle
+      });
+      const message = { type, requestId, data };
+      this.ws.send(JSON.stringify(message));
+      console.log(`\u{1F4E4} Sent request to server:`, message);
+    });
+  };
+  receiveMessage = (type, data) => {
+    try {
+      console.log(`\u{1F4E8} Received from server: ${type}, data:`, data);
+      this.emitter.emit(type, data);
+    } catch (error) {
+      console.error("\u274C Error parsing message:", error);
+    }
+  };
+  enableBroadcast = async () => {
+    console.log("WebTransport.sync.enableBroadcast");
+    try {
+      const result = await this.sendRequest(
+        MESSAGES.enableBroadcast
+      );
+      console.log("WebTransport.sync.enableBroadcast result:", result);
+      return result.broadcastId;
+    } catch (error) {
+      console.error("Failed to enable broadcast:", error);
+      throw error;
+    }
+  };
+  connect = async (topic, name, app) => {
+    console.log("WebTransport.sync.connect");
+    try {
+      await this.sendRequest(MESSAGES.connect, { topic, name, app });
+    } catch (error) {
+      console.error("Failed to connect:", error);
+      throw error;
+    }
+  };
+  requestKeystore = async (pin) => {
+    console.log("WebTransport.sync.requestKeystore");
+    try {
+      await this.sendRequest(MESSAGES.requestKeystore, { pin });
+    } catch (error) {
+      console.error("Failed to request keystore:", error);
+      throw error;
+    }
+  };
+  approveRequest = async (data) => {
+    console.log("WebTransport.sync.approveRequest");
+    try {
+      await this.sendRequest(MESSAGES.approveRequest, {
+        identity: data.identity,
+        appId: data.appId
+      });
+    } catch (error) {
+      console.error("Failed to approve request:", error);
+      throw error;
+    }
+  };
+  denyRequest = async () => {
+    console.log("WebTransport.sync.denyRequest");
+    try {
+      await this.sendRequest(MESSAGES.denyRequest);
+    } catch (error) {
+      console.error("Failed to deny request:", error);
+      throw error;
+    }
+  };
+  disableBroadcast = async () => {
+    console.log("WebTransport.sync.disableBroadcast");
+    try {
+      await this.sendRequest(MESSAGES.disableBroadcast);
+    } catch (error) {
+      console.error("Failed to disable broadcast:", error);
+      throw error;
+    }
+  };
+  // Event listeners remain the same
+  onClientConnection = async (callback) => {
+    console.log(
+      "\u{1F442} WebTransport.sync.onClientConnection - registering listener"
+    );
+    this.emitter.on(MESSAGES.onClientConnection, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onClientConnection, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onClientConnection}`);
+    };
+  };
+  onKeystoreRequestInvalidPIN = async (callback) => {
+    console.log(
+      "\u{1F442} WebTransport.sync.onKeystoreRequestInvalidPIN - registering listener"
+    );
+    this.emitter.on(MESSAGES.onKeystoreRequestInvalidPIN, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onKeystoreRequestInvalidPIN, callback);
+      console.log(
+        `\u{1F507} Unsubscribed from ${MESSAGES.onKeystoreRequestInvalidPIN}`
+      );
+    };
+  };
+  onKeystoreRequestValidPIN = async (callback) => {
+    console.log(
+      "\u{1F442} WebTransport.sync.onKeystoreRequestValidPIN - registering listener"
+    );
+    this.emitter.on(MESSAGES.onKeystoreRequestValidPIN, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onKeystoreRequestValidPIN, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onKeystoreRequestValidPIN}`);
+    };
+  };
+  onKeystoreRequest = async (callback) => {
+    console.log(
+      "\u{1F442} WebTransport.sync.onKeystoreRequest - registering listener"
+    );
+    this.emitter.on(MESSAGES.onKeystoreRequest, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onKeystoreRequest, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onKeystoreRequest}`);
+    };
+  };
+  onClientApproval = async (callback) => {
+    console.log("\u{1F442} WebTransport.sync.onClientApproval - registering listener");
+    this.emitter.on(MESSAGES.onClientApproval, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onClientApproval, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onClientApproval}`);
+    };
+  };
+  onClientDenial = async (callback) => {
+    console.log("\u{1F442} WebTransport.sync.onClientDenial - registering listener");
+    this.emitter.on(MESSAGES.onClientDenial, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onClientDenial, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onClientDenial}`);
+    };
+  };
+  onCompletion = async (callback) => {
+    console.log("\u{1F442} WebTransport.sync.onCompletion - registering listener");
+    this.emitter.on(MESSAGES.onCompletion, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onCompletion, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onCompletion}`);
+    };
+  };
+  onBroadcastDisable = async (callback) => {
+    console.log(
+      "\u{1F442} WebTransport.sync.onBroadcastDisable - registering listener"
+    );
+    this.emitter.on(MESSAGES.onBroadcastDisable, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onBroadcastDisable, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onBroadcastDisable}`);
+    };
+  };
+  getDeviceInfo = async () => {
+    console.log("KeyTransportClient.getDeviceInfo");
+    try {
+      const info = await this.sendRequest(MESSAGES.getDeviceInfo);
+      return info;
+    } catch (error) {
+      console.error("Failed to get device info:", error);
+      throw error;
+    }
+  };
+  getHostname = async () => {
+    console.log("KeyTransportClient.getHostname");
+    try {
+      const result = await this.sendRequest(
+        MESSAGES.getHostname
+      );
+      return result.hostname;
+    } catch (error) {
+      console.error("Failed to get hostname:", error);
+      throw error;
+    }
+  };
+  connectPresence = async (topic) => {
+    console.log("KeyTransportClient.connectPresence");
+    try {
+      await this.sendRequest(MESSAGES.connectPresence, { topic });
+    } catch (error) {
+      console.error("Failed to connect presence:", error);
+      throw error;
+    }
+  };
+  broadcastClientState = async (id, state) => {
+    console.log("KeyTransportClient.broadcastClientState");
+    this.peers.set(id, state);
+    try {
+      await this.sendRequest(MESSAGES.broadcastClientState, { id, state });
+    } catch (error) {
+      console.error("Failed to broadcast client state:", error);
+      throw error;
+    }
+  };
+  onClientStateRequest = async (callback) => {
+    console.log(
+      "\u{1F442} KeyTransportClient.onClientStateRequest - registering listener"
+    );
+    this.emitter.on(MESSAGES.onClientStateRequest, callback);
+    return () => {
+      this.emitter.off(MESSAGES.onClientStateRequest, callback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onClientStateRequest}`);
+    };
+  };
+  onClientStateUpdate = async (callback) => {
+    console.log(
+      "\u{1F442} KeyTransportClient.onClientStateUpdate - registering listener"
+    );
+    const wrappedCallback = (response) => {
+      this.peers.set(response.id, response.state);
+      callback(response);
+    };
+    this.emitter.on(MESSAGES.onClientStateUpdate, wrappedCallback);
+    return () => {
+      this.emitter.off(MESSAGES.onClientStateUpdate, wrappedCallback);
+      console.log(`\u{1F507} Unsubscribed from ${MESSAGES.onClientStateUpdate}`);
+    };
+  };
+  getPeerState = (id) => {
+    return this.peers.get(id);
+  };
+  getAllPeers = () => {
+    return this.peers;
+  };
+  /**
+   * Reconnect to the WebSocket server
+   */
+  reconnect = () => {
+    console.log("\u{1F504} Attempting to reconnect...");
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    if (this.connectionResolver) {
+      this.connectionResolver = null;
+    }
+    this.connectionPromise = null;
+    this.connectionPromise = this.connectWebSocket();
+  };
+  /**
+   * Close the WebSocket connection
+   */
+  disconnect = () => {
+    console.log("\u{1F50C} Disconnecting...");
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  };
+  /**
+   * Check if WebSocket is connected
+   */
+  isConnected = () => {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  };
+};
+export {
+  KeyTransportClient
+};

package/dist/server.d.mts

@@ -0,0 +1,46 @@
+import { StoredIdentity } from '@cryptforge/core';
+import WebSocket from 'ws';
+
+type OnSetupEventCallback = (options: {
+    route: string;
+    data: Record<string, any>;
+}) => void;
+
+declare function useKeyExchangeServer(onEvent: OnSetupEventCallback): {
+    getKey: () => string;
+    getPIN: () => string;
+    beginBroadcast: () => Promise<void>;
+    endBroadcast: () => Promise<void>;
+    approveRequest: (identity: StoredIdentity, appId: number) => Promise<void>;
+    completeSetupSuccess: () => Promise<void>;
+    rejectRequest: () => Promise<void>;
+    broadcastDisabled: () => Promise<void>;
+};
+
+interface WebSocketServerConfig {
+    port?: number;
+    onConnection?: (ws: WebSocket) => void;
+    onDisconnection?: (ws: WebSocket) => void;
+    logger?: {
+        log: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+    };
+}
+declare class KeyTransportServer {
+    private wss;
+    private activeConnections;
+    private core;
+    private port;
+    private logger;
+    constructor(config: WebSocketServerConfig);
+    private handleEvent;
+    private sendResponse;
+    private broadcastEvent;
+    private setupServerHandlers;
+    private handleMessage;
+    close: (callback?: (err?: Error) => void) => void;
+    getActiveConnections: () => Set<WebSocket>;
+    getPort: () => number;
+}
+
+export { KeyTransportServer, useKeyExchangeServer };

package/dist/server.d.ts

@@ -0,0 +1,46 @@
+import { StoredIdentity } from '@cryptforge/core';
+import WebSocket from 'ws';
+
+type OnSetupEventCallback = (options: {
+    route: string;
+    data: Record<string, any>;
+}) => void;
+
+declare function useKeyExchangeServer(onEvent: OnSetupEventCallback): {
+    getKey: () => string;
+    getPIN: () => string;
+    beginBroadcast: () => Promise<void>;
+    endBroadcast: () => Promise<void>;
+    approveRequest: (identity: StoredIdentity, appId: number) => Promise<void>;
+    completeSetupSuccess: () => Promise<void>;
+    rejectRequest: () => Promise<void>;
+    broadcastDisabled: () => Promise<void>;
+};
+
+interface WebSocketServerConfig {
+    port?: number;
+    onConnection?: (ws: WebSocket) => void;
+    onDisconnection?: (ws: WebSocket) => void;
+    logger?: {
+        log: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+    };
+}
+declare class KeyTransportServer {
+    private wss;
+    private activeConnections;
+    private core;
+    private port;
+    private logger;
+    constructor(config: WebSocketServerConfig);
+    private handleEvent;
+    private sendResponse;
+    private broadcastEvent;
+    private setupServerHandlers;
+    private handleMessage;
+    close: (callback?: (err?: Error) => void) => void;
+    getActiveConnections: () => Set<WebSocket>;
+    getPort: () => number;
+}
+
+export { KeyTransportServer, useKeyExchangeServer };