@cryptforge/key-exchange 0.1.0

package/dist/electron-preload.d.mts

@@ -0,0 +1,3 @@
+declare const setupKeyExchangePreloadAPI: () => void;
+
+export { setupKeyExchangePreloadAPI };

package/dist/electron-preload.d.ts

@@ -0,0 +1,3 @@
+declare const setupKeyExchangePreloadAPI: () => void;
+
+export { setupKeyExchangePreloadAPI };

package/dist/electron-preload.js

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/electron-preload.ts
+var electron_preload_exports = {};
+__export(electron_preload_exports, {
+  setupKeyExchangePreloadAPI: () => setupKeyExchangePreloadAPI
+});
+module.exports = __toCommonJS(electron_preload_exports);
+
+// src/electron/preload/setupExchangePreload.ts
+var import_electron = require("electron");
+
+// 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/electron/preload/setupExchangePreload.ts
+var setupKeyExchangePreloadAPI = () => {
+  import_electron.contextBridge.exposeInMainWorld("keyExchangeElectronAPI", {
+    // sync setup
+    enableBroadcast: () => import_electron.ipcRenderer.invoke(MESSAGES.enableBroadcast),
+    connect: (topic, name, app) => import_electron.ipcRenderer.invoke(MESSAGES.connect, topic, name, app),
+    onClientConnection: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onClientConnection,
+      (_event, response) => callback(response)
+    ),
+    requestKeystore: (pin) => import_electron.ipcRenderer.invoke(MESSAGES.requestKeystore, pin),
+    onKeystoreRequestInvalidPIN: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onKeystoreRequestInvalidPIN,
+      (_event, response) => callback(response)
+    ),
+    onKeystoreRequestValidPIN: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onKeystoreRequestValidPIN,
+      (_event, response) => callback(response)
+    ),
+    onKeystoreRequest: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onKeystoreRequest,
+      (_event, response) => callback(response)
+    ),
+    approveRequest: (data) => import_electron.ipcRenderer.invoke(MESSAGES.approveRequest, data),
+    onClientApproval: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onClientApproval,
+      (_event, response) => callback(response)
+    ),
+    denyRequest: () => import_electron.ipcRenderer.invoke(MESSAGES.denyRequest),
+    onClientDenial: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onClientDenial,
+      (_event, response) => callback(response)
+    ),
+    onCompletion: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onCompletion,
+      (_event, response) => callback(response)
+    ),
+    disableBroadcast: () => import_electron.ipcRenderer.invoke(MESSAGES.disableBroadcast),
+    onBroadcastDisable: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onBroadcastDisable,
+      (_event, response) => callback(response)
+    ),
+    getDeviceInfo: () => import_electron.ipcRenderer.invoke(MESSAGES.getDeviceInfo),
+    getHostname: () => import_electron.ipcRenderer.invoke(MESSAGES.getHostname),
+    connectPresence: (topic) => import_electron.ipcRenderer.invoke(MESSAGES.connectPresence, topic),
+    broadcastClientState: (id, state) => import_electron.ipcRenderer.invoke(MESSAGES.broadcastClientState, id, state),
+    onClientStateRequest: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onClientStateRequest,
+      (_event) => callback()
+    ),
+    onClientStateUpdate: (callback) => import_electron.ipcRenderer.on(
+      MESSAGES.onClientStateUpdate,
+      (_event, response) => callback(response)
+    )
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupKeyExchangePreloadAPI
+});

package/dist/electron-preload.mjs

@@ -0,0 +1,87 @@
+// src/electron/preload/setupExchangePreload.ts
+import { ipcRenderer, contextBridge } from "electron";
+
+// 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/electron/preload/setupExchangePreload.ts
+var setupKeyExchangePreloadAPI = () => {
+  contextBridge.exposeInMainWorld("keyExchangeElectronAPI", {
+    // sync setup
+    enableBroadcast: () => ipcRenderer.invoke(MESSAGES.enableBroadcast),
+    connect: (topic, name, app) => ipcRenderer.invoke(MESSAGES.connect, topic, name, app),
+    onClientConnection: (callback) => ipcRenderer.on(
+      MESSAGES.onClientConnection,
+      (_event, response) => callback(response)
+    ),
+    requestKeystore: (pin) => ipcRenderer.invoke(MESSAGES.requestKeystore, pin),
+    onKeystoreRequestInvalidPIN: (callback) => ipcRenderer.on(
+      MESSAGES.onKeystoreRequestInvalidPIN,
+      (_event, response) => callback(response)
+    ),
+    onKeystoreRequestValidPIN: (callback) => ipcRenderer.on(
+      MESSAGES.onKeystoreRequestValidPIN,
+      (_event, response) => callback(response)
+    ),
+    onKeystoreRequest: (callback) => ipcRenderer.on(
+      MESSAGES.onKeystoreRequest,
+      (_event, response) => callback(response)
+    ),
+    approveRequest: (data) => ipcRenderer.invoke(MESSAGES.approveRequest, data),
+    onClientApproval: (callback) => ipcRenderer.on(
+      MESSAGES.onClientApproval,
+      (_event, response) => callback(response)
+    ),
+    denyRequest: () => ipcRenderer.invoke(MESSAGES.denyRequest),
+    onClientDenial: (callback) => ipcRenderer.on(
+      MESSAGES.onClientDenial,
+      (_event, response) => callback(response)
+    ),
+    onCompletion: (callback) => ipcRenderer.on(
+      MESSAGES.onCompletion,
+      (_event, response) => callback(response)
+    ),
+    disableBroadcast: () => ipcRenderer.invoke(MESSAGES.disableBroadcast),
+    onBroadcastDisable: (callback) => ipcRenderer.on(
+      MESSAGES.onBroadcastDisable,
+      (_event, response) => callback(response)
+    ),
+    getDeviceInfo: () => ipcRenderer.invoke(MESSAGES.getDeviceInfo),
+    getHostname: () => ipcRenderer.invoke(MESSAGES.getHostname),
+    connectPresence: (topic) => ipcRenderer.invoke(MESSAGES.connectPresence, topic),
+    broadcastClientState: (id, state) => ipcRenderer.invoke(MESSAGES.broadcastClientState, id, state),
+    onClientStateRequest: (callback) => ipcRenderer.on(
+      MESSAGES.onClientStateRequest,
+      (_event) => callback()
+    ),
+    onClientStateUpdate: (callback) => ipcRenderer.on(
+      MESSAGES.onClientStateUpdate,
+      (_event, response) => callback(response)
+    )
+  });
+};
+export {
+  setupKeyExchangePreloadAPI
+};

package/dist/electron-renderer.d.mts

@@ -0,0 +1,74 @@
+import { StoredIdentity, ClientConnectionState, KeyTransportAdapter } from '@cryptforge/core';
+
+/**
+ * Type definitions for Electron key exchange API
+ */
+
+interface KeyExchangeElectronAPI {
+    enableBroadcast: () => Promise<string>;
+    connect: (topic: string, name: string, app: string) => Promise<void>;
+    onClientConnection: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    requestKeystore: (pin: string) => Promise<void>;
+    onKeystoreRequestInvalidPIN: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequestValidPIN: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequest: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    approveRequest: (data: {
+        identity: StoredIdentity;
+        appId: number;
+    }) => Promise<void>;
+    onClientApproval: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    denyRequest: () => Promise<void>;
+    onClientDenial: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onCompletion: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    disableBroadcast: () => Promise<void>;
+    onBroadcastDisable: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    getDeviceInfo: () => Promise<Record<string, any>>;
+    getHostname: () => Promise<string>;
+    connectPresence: (topic: string) => Promise<void>;
+    broadcastClientState: (id: string, state: ClientConnectionState) => Promise<void>;
+    onClientStateRequest: (callback: () => void) => Promise<() => void>;
+    onClientStateUpdate: (callback: (response: {
+        id: string;
+        state: ClientConnectionState;
+    }) => void) => Promise<() => void>;
+}
+
+declare global {
+    interface Window {
+        keyExchangeElectronAPI: KeyExchangeElectronAPI;
+    }
+}
+declare class KeyTransportRenderer implements KeyTransportAdapter {
+    private peers;
+    constructor();
+    enableBroadcast: () => Promise<string>;
+    connect: (_topic: string, _name: string, _app: string) => Promise<void>;
+    onClientConnection: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    requestKeystore: (_pin: string) => Promise<void>;
+    onKeystoreRequestInvalidPIN: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequestValidPIN: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequest: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    approveRequest: (data: {
+        identity: StoredIdentity;
+        appId: number;
+    }) => Promise<void>;
+    onClientApproval: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    denyRequest: () => Promise<void>;
+    onClientDenial: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onCompletion: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    disableBroadcast: () => Promise<void>;
+    onBroadcastDisable: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    getDeviceInfo: () => Promise<Record<string, any>>;
+    getHostname: () => Promise<string>;
+    connectPresence: (topic: string) => Promise<void>;
+    broadcastClientState: (id: string, state: ClientConnectionState) => Promise<void>;
+    onClientStateRequest: (callback: () => void) => Promise<() => void>;
+    onClientStateUpdate: (callback: (response: {
+        id: string;
+        state: ClientConnectionState;
+    }) => void) => Promise<() => void>;
+    getPeerState: (id: string) => ClientConnectionState | undefined;
+    getAllPeers: () => ReadonlyMap<string, ClientConnectionState>;
+}
+
+export { KeyTransportRenderer as ElectronKeyTransport, type KeyExchangeElectronAPI, KeyTransportRenderer };

package/dist/electron-renderer.d.ts

@@ -0,0 +1,74 @@
+import { StoredIdentity, ClientConnectionState, KeyTransportAdapter } from '@cryptforge/core';
+
+/**
+ * Type definitions for Electron key exchange API
+ */
+
+interface KeyExchangeElectronAPI {
+    enableBroadcast: () => Promise<string>;
+    connect: (topic: string, name: string, app: string) => Promise<void>;
+    onClientConnection: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    requestKeystore: (pin: string) => Promise<void>;
+    onKeystoreRequestInvalidPIN: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequestValidPIN: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequest: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    approveRequest: (data: {
+        identity: StoredIdentity;
+        appId: number;
+    }) => Promise<void>;
+    onClientApproval: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    denyRequest: () => Promise<void>;
+    onClientDenial: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onCompletion: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    disableBroadcast: () => Promise<void>;
+    onBroadcastDisable: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    getDeviceInfo: () => Promise<Record<string, any>>;
+    getHostname: () => Promise<string>;
+    connectPresence: (topic: string) => Promise<void>;
+    broadcastClientState: (id: string, state: ClientConnectionState) => Promise<void>;
+    onClientStateRequest: (callback: () => void) => Promise<() => void>;
+    onClientStateUpdate: (callback: (response: {
+        id: string;
+        state: ClientConnectionState;
+    }) => void) => Promise<() => void>;
+}
+
+declare global {
+    interface Window {
+        keyExchangeElectronAPI: KeyExchangeElectronAPI;
+    }
+}
+declare class KeyTransportRenderer implements KeyTransportAdapter {
+    private peers;
+    constructor();
+    enableBroadcast: () => Promise<string>;
+    connect: (_topic: string, _name: string, _app: string) => Promise<void>;
+    onClientConnection: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    requestKeystore: (_pin: string) => Promise<void>;
+    onKeystoreRequestInvalidPIN: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequestValidPIN: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequest: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    approveRequest: (data: {
+        identity: StoredIdentity;
+        appId: number;
+    }) => Promise<void>;
+    onClientApproval: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    denyRequest: () => Promise<void>;
+    onClientDenial: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onCompletion: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    disableBroadcast: () => Promise<void>;
+    onBroadcastDisable: (_callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    getDeviceInfo: () => Promise<Record<string, any>>;
+    getHostname: () => Promise<string>;
+    connectPresence: (topic: string) => Promise<void>;
+    broadcastClientState: (id: string, state: ClientConnectionState) => Promise<void>;
+    onClientStateRequest: (callback: () => void) => Promise<() => void>;
+    onClientStateUpdate: (callback: (response: {
+        id: string;
+        state: ClientConnectionState;
+    }) => void) => Promise<() => void>;
+    getPeerState: (id: string) => ClientConnectionState | undefined;
+    getAllPeers: () => ReadonlyMap<string, ClientConnectionState>;
+}
+
+export { KeyTransportRenderer as ElectronKeyTransport, type KeyExchangeElectronAPI, KeyTransportRenderer };

package/dist/electron-renderer.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/electron-renderer.ts
+var electron_renderer_exports = {};
+__export(electron_renderer_exports, {
+  ElectronKeyTransport: () => KeyTransportRenderer,
+  KeyTransportRenderer: () => KeyTransportRenderer
+});
+module.exports = __toCommonJS(electron_renderer_exports);
+
+// src/electron/renderer/keyTransportRenderer.ts
+var KeyTransportRenderer = class {
+  peers = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  enableBroadcast = async () => {
+    return window.keyExchangeElectronAPI.enableBroadcast();
+  };
+  connect = async (_topic, _name, _app) => {
+    return window.keyExchangeElectronAPI.connect(_topic, _name, _app);
+  };
+  onClientConnection = async (_callback) => {
+    return window.keyExchangeElectronAPI.onClientConnection(_callback);
+  };
+  requestKeystore = async (_pin) => {
+    return window.keyExchangeElectronAPI.requestKeystore(_pin);
+  };
+  onKeystoreRequestInvalidPIN = async (_callback) => {
+    return window.keyExchangeElectronAPI.onKeystoreRequestInvalidPIN(_callback);
+  };
+  onKeystoreRequestValidPIN = async (_callback) => {
+    return window.keyExchangeElectronAPI.onKeystoreRequestValidPIN(_callback);
+  };
+  onKeystoreRequest = async (_callback) => {
+    return window.keyExchangeElectronAPI.onKeystoreRequest(_callback);
+  };
+  approveRequest = async (data) => {
+    return window.keyExchangeElectronAPI.approveRequest(data);
+  };
+  onClientApproval = async (_callback) => {
+    return window.keyExchangeElectronAPI.onClientApproval(_callback);
+  };
+  denyRequest = async () => {
+    return window.keyExchangeElectronAPI.denyRequest();
+  };
+  onClientDenial = async (_callback) => {
+    return window.keyExchangeElectronAPI.onClientDenial(_callback);
+  };
+  onCompletion = async (_callback) => {
+    return window.keyExchangeElectronAPI.onCompletion(_callback);
+  };
+  disableBroadcast = async () => {
+    return window.keyExchangeElectronAPI.disableBroadcast();
+  };
+  onBroadcastDisable = async (_callback) => {
+    return window.keyExchangeElectronAPI.onBroadcastDisable(_callback);
+  };
+  getDeviceInfo = async () => {
+    return window.keyExchangeElectronAPI.getDeviceInfo();
+  };
+  getHostname = async () => {
+    return window.keyExchangeElectronAPI.getHostname();
+  };
+  connectPresence = async (topic) => {
+    return window.keyExchangeElectronAPI.connectPresence(topic);
+  };
+  broadcastClientState = async (id, state) => {
+    return window.keyExchangeElectronAPI.broadcastClientState(id, state);
+  };
+  onClientStateRequest = async (callback) => {
+    return window.keyExchangeElectronAPI.onClientStateRequest(callback);
+  };
+  onClientStateUpdate = async (callback) => {
+    const wrappedCallback = (response) => {
+      this.peers.set(response.id, response.state);
+      callback(response);
+    };
+    return window.keyExchangeElectronAPI.onClientStateUpdate(wrappedCallback);
+  };
+  getPeerState = (id) => {
+    return this.peers.get(id);
+  };
+  getAllPeers = () => {
+    return this.peers;
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ElectronKeyTransport,
+  KeyTransportRenderer
+});

package/dist/electron-renderer.mjs

@@ -0,0 +1,80 @@
+// src/electron/renderer/keyTransportRenderer.ts
+var KeyTransportRenderer = class {
+  peers = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  enableBroadcast = async () => {
+    return window.keyExchangeElectronAPI.enableBroadcast();
+  };
+  connect = async (_topic, _name, _app) => {
+    return window.keyExchangeElectronAPI.connect(_topic, _name, _app);
+  };
+  onClientConnection = async (_callback) => {
+    return window.keyExchangeElectronAPI.onClientConnection(_callback);
+  };
+  requestKeystore = async (_pin) => {
+    return window.keyExchangeElectronAPI.requestKeystore(_pin);
+  };
+  onKeystoreRequestInvalidPIN = async (_callback) => {
+    return window.keyExchangeElectronAPI.onKeystoreRequestInvalidPIN(_callback);
+  };
+  onKeystoreRequestValidPIN = async (_callback) => {
+    return window.keyExchangeElectronAPI.onKeystoreRequestValidPIN(_callback);
+  };
+  onKeystoreRequest = async (_callback) => {
+    return window.keyExchangeElectronAPI.onKeystoreRequest(_callback);
+  };
+  approveRequest = async (data) => {
+    return window.keyExchangeElectronAPI.approveRequest(data);
+  };
+  onClientApproval = async (_callback) => {
+    return window.keyExchangeElectronAPI.onClientApproval(_callback);
+  };
+  denyRequest = async () => {
+    return window.keyExchangeElectronAPI.denyRequest();
+  };
+  onClientDenial = async (_callback) => {
+    return window.keyExchangeElectronAPI.onClientDenial(_callback);
+  };
+  onCompletion = async (_callback) => {
+    return window.keyExchangeElectronAPI.onCompletion(_callback);
+  };
+  disableBroadcast = async () => {
+    return window.keyExchangeElectronAPI.disableBroadcast();
+  };
+  onBroadcastDisable = async (_callback) => {
+    return window.keyExchangeElectronAPI.onBroadcastDisable(_callback);
+  };
+  getDeviceInfo = async () => {
+    return window.keyExchangeElectronAPI.getDeviceInfo();
+  };
+  getHostname = async () => {
+    return window.keyExchangeElectronAPI.getHostname();
+  };
+  connectPresence = async (topic) => {
+    return window.keyExchangeElectronAPI.connectPresence(topic);
+  };
+  broadcastClientState = async (id, state) => {
+    return window.keyExchangeElectronAPI.broadcastClientState(id, state);
+  };
+  onClientStateRequest = async (callback) => {
+    return window.keyExchangeElectronAPI.onClientStateRequest(callback);
+  };
+  onClientStateUpdate = async (callback) => {
+    const wrappedCallback = (response) => {
+      this.peers.set(response.id, response.state);
+      callback(response);
+    };
+    return window.keyExchangeElectronAPI.onClientStateUpdate(wrappedCallback);
+  };
+  getPeerState = (id) => {
+    return this.peers.get(id);
+  };
+  getAllPeers = () => {
+    return this.peers;
+  };
+};
+export {
+  KeyTransportRenderer as ElectronKeyTransport,
+  KeyTransportRenderer
+};

package/dist/index.d.mts

@@ -0,0 +1,65 @@
+import { KeyTransportAdapter, StoredIdentity, ClientConnectionState } from '@cryptforge/core';
+
+declare class KeyTransportClient implements KeyTransportAdapter {
+    private emitter;
+    private ws;
+    private serverUrl;
+    private pendingRequests;
+    private requestTimeout;
+    private requestCounter;
+    private connectionPromise;
+    private connectionResolver;
+    private peers;
+    constructor(serverUrl?: string);
+    private connectWebSocket;
+    private generateRequestId;
+    private handleRequestResponse;
+    private rejectAllPendingRequests;
+    /**
+     * Send a request and wait for response
+     */
+    private sendRequest;
+    private receiveMessage;
+    enableBroadcast: () => Promise<string>;
+    connect: (topic: string, name: string, app: string) => Promise<void>;
+    requestKeystore: (pin: string) => Promise<void>;
+    approveRequest: (data: {
+        identity: StoredIdentity;
+        appId: number;
+    }) => Promise<void>;
+    denyRequest: () => Promise<void>;
+    disableBroadcast: () => Promise<void>;
+    onClientConnection: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequestInvalidPIN: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequestValidPIN: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onKeystoreRequest: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onClientApproval: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onClientDenial: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onCompletion: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    onBroadcastDisable: (callback: (response: Record<string, any>) => void) => Promise<() => void>;
+    getDeviceInfo: () => Promise<Record<string, any>>;
+    getHostname: () => Promise<string>;
+    connectPresence: (topic: string) => Promise<void>;
+    broadcastClientState: (id: string, state: ClientConnectionState) => Promise<void>;
+    onClientStateRequest: (callback: () => void) => Promise<() => void>;
+    onClientStateUpdate: (callback: (response: {
+        id: string;
+        state: ClientConnectionState;
+    }) => void) => Promise<() => void>;
+    getPeerState: (id: string) => ClientConnectionState | undefined;
+    getAllPeers: () => ReadonlyMap<string, ClientConnectionState>;
+    /**
+     * Reconnect to the WebSocket server
+     */
+    reconnect: () => void;
+    /**
+     * Close the WebSocket connection
+     */
+    disconnect: () => void;
+    /**
+     * Check if WebSocket is connected
+     */
+    isConnected: () => boolean;
+}
+
+export { KeyTransportClient };