@persistica/flux-agent 0.0.1 → 0.0.2

package/index.cjs

@@ -17,19 +17,1083 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/flux/agent-2/src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  persisticaFluxAgent2: () => persisticaFluxAgent2
+// packages/flux/agent/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FluxAgent: () => FluxAgent
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
-// packages/flux/agent-2/src/lib/persistica-flux-agent-2.ts
-function persisticaFluxAgent2() {
-  return "persistica-flux-agent-2";
+// libs/flux/shared/types/src/lib/channel.type.ts
+var validateChannelNameOrThrow = (channelName) => {
+  if (channelName.includes(":")) {
+    throw new Error("Channel name cannot contain :");
+  }
+  if (channelName.includes("/")) {
+    throw new Error("Channel name cannot contain /");
+  }
+  if (!/^[A-Za-z0-9-]+$/.test(channelName)) {
+    throw new Error("Channel name can only contain letters, numbers and dashes ('-')");
+  }
+  if (channelName.length > 100) {
+    throw new Error("Channel name cannot be longer than 100 characters");
+  }
+  return true;
+};
+
+// libs/flux/shared/types/src/lib/auth/auth.fn.ts
+var checkAuthTicketShape = (ticket) => {
+  return typeof ticket === "string";
+};
+
+// libs/flux/shared/types/src/lib/low-level-ws.interfaces.ts
+var RPC_REQUEST = "rpc-request";
+var RPC_RESPONSE = "rpc-response";
+var CONNECT_TO_CLIENT = "connect-to-client";
+var NETWORK_CHANNEL_PUBLISH = "nc-pub";
+var ON_NETWORK_CHANNEL_PUBLISH = "nc-on-pub";
+var SUBSCRIBE_NETWORK_CHANNEL_NAME = "subscribe-to-nc-name";
+var SUBSCRIBED_NETWORK_CHANNEL_NAME = "subscribed-to-nc-name";
+var UNSUBSCRIBE_NETWORK_CHANNEL_NAME = "unsubscribe-nc-name";
+var AUTHORITY_CHANNEL_SUBSCRIBE = "acs";
+var AUTHORITY_DISCONNECT_AGENT = "ada";
+
+// libs/flux/shared/types/src/lib/client.type.ts
+var validateAgentUIDOrThrow = (clientOwnUID) => {
+  if (typeof clientOwnUID !== "string") {
+    throw new Error("UID must be a string");
+  }
+  if (!/^[A-Za-z0-9-]+$/.test(clientOwnUID)) {
+    throw new Error("UID can only contain letters, numbers and dashes ('-')");
+  }
+  if (clientOwnUID.length > 50) {
+    throw new Error("UID cannot be longer than 50 characters");
+  }
+  return true;
+};
+
+// libs/flux/shared/ws/src/lib/rpc/rpc-server.class.ts
+var RPCServer = class {
+  methods = /* @__PURE__ */ new Map();
+  /**
+   * Registers a method to be called by the client.
+   * 
+   * @param { TMethodName }   methodName
+   * @param { TCallback }     fn
+   * 
+   * @returns { void }
+   */
+  registerMethod(methodName, fn) {
+    const existingMethod = this.methods.get(methodName);
+    if (existingMethod && existingMethod !== fn) {
+      throw new Error(`Method '${methodName}' already registered`);
+    }
+    this.methods.set(methodName, fn);
+  }
+  /**
+   * Handles the request from the client.
+   * 
+   * @param { RPCRequest }    request
+   * @param { Function }      sendToRPCClient
+   * 
+   * @returns { void } 
+   */
+  async handleMessage(request, sendToRPCClient) {
+    const response = {
+      id: request.id,
+      rpcProcessAddress: request.originProcessAddress,
+      result: null
+    };
+    const method = this.methods.get(request.method);
+    if (method) {
+      try {
+        response.result = await method(...request.params);
+      } catch (error) {
+        response.error = error.message;
+      }
+    } else {
+      response.error = `Method '${request.method}' not found`;
+    }
+    sendToRPCClient(response);
+  }
+};
+
+// libs/flux/shared/ws/src/lib/ws-client.ts
+var WebSocketClient = class extends RPCServer {
+  options;
+  eventListeners = {
+    open: [],
+    message: [],
+    close: [],
+    error: [],
+    connecting: []
+  };
+  reconnectAttempts = 0;
+  ws;
+  isOpen = false;
+  // Is the connection open
+  constructor(options) {
+    super();
+    this.options = {
+      autoReconnect: true,
+      reconnectDelay: 1e3,
+      heartbeatInterval: 6e4,
+      connectionTimeout: 5e3,
+      ...options
+    };
+  }
+  /**
+   * 
+   * @returns { Promise<void> }
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      this.emit("connecting", this.reconnectAttempts);
+      this.ws = new WebSocket(
+        this.options.url
+      );
+      const timeout = setTimeout(() => {
+        if (this.ws?.readyState !== WebSocket.OPEN) {
+          this.ws?.close();
+          reject(new Error("Connection timeout"));
+        }
+      }, this.options.connectionTimeout);
+      this.ws.onopen = () => {
+        clearTimeout(timeout);
+        this.reconnectAttempts = 0;
+        this.isOpen = true;
+        this.emit("open");
+        resolve();
+      };
+      this.ws.onmessage = (event) => {
+        this.emit("message", event.data);
+      };
+      this.ws.onclose = () => {
+        clearTimeout(timeout);
+        if (this.isOpen) {
+          this.emit("close");
+          this.isOpen = false;
+        }
+        if (this.options.autoReconnect && (this.options.retries === void 0 || this.reconnectAttempts < this.options.retries)) {
+          setTimeout(() => {
+            this.reconnectAttempts++;
+            this.connect();
+          }, Math.min(this.options.reconnectDelay ?? Number.POSITIVE_INFINITY, this.options.reconnectDelay * (this.reconnectAttempts || 1)));
+        } else if (this.options.autoReconnect) {
+          this.emit("error", new Error("Connection failed: retries exhausted"));
+        }
+      };
+      this.ws.onerror = (event) => {
+        if (event?.message?.includes("Failed to connect")) {
+        } else {
+          console.log("\u274C Error", event.message);
+        }
+      };
+    });
+  }
+  emit(event, data) {
+    for (const listener of this.eventListeners[event]) {
+      listener(data);
+    }
+  }
+  on(event, listener) {
+    this.eventListeners[event].push(listener);
+    return this;
+  }
+  /**
+   * Clears all subscribers.
+   * 
+   * @returns { void }
+   */
+  clearEventSubscribers() {
+    this.eventListeners.open = [];
+    this.eventListeners.message = [];
+    this.eventListeners.close = [];
+    this.eventListeners.connecting = [];
+    this.eventListeners.error = [];
+  }
+  send(message) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(message);
+    } else {
+      console.warn("WebSocket not open.");
+    }
+  }
+  close() {
+    this.options.autoReconnect = false;
+    this.ws?.close();
+    this.clearEventSubscribers();
+  }
+};
+var FluxWebSocketClientConnection = class extends WebSocketClient {
+};
+
+// packages/flux/agent/src/lib/flux-remote-client.class.ts
+var FluxRemoteClient = class {
+  constructor(iceConnection) {
+    this.iceConnection = iceConnection;
+  }
+  callProcedure() {
+  }
+  send(message) {
+    this.iceConnection.sendMessage(message);
+  }
+};
+
+// packages/flux/agent/src/lib/connector/low-level-com/web-rtc/ice-connection.ts
+var peerConnectionConfig = {
+  iceServers: [
+    { urls: "stun:stun.stunprotocol.org:3478" },
+    { urls: "stun:stun2.1.google.com:19302" },
+    { urls: "stun:stun.l.google.com:19302" }
+  ]
+};
+var ICEConnection = class {
+  constructor(_fluxWebSocketClientConnection, _stateChange) {
+    this._fluxWebSocketClientConnection = _fluxWebSocketClientConnection;
+    this._stateChange = _stateChange;
+    this.peerConnection.ondatachannel = (event) => {
+      console.log("*********** GOT DATAT SCHANNNEL ");
+      this.dataChannel = event.channel;
+      this.dataChannel.onopen = () => console.log("ReceiveChannel opened");
+      this.dataChannel.onmessage = (event2) => {
+        console.log("Receiving ICE event", event2);
+      };
+      this.dataChannel.onopen = () => {
+        console.log("Opened");
+      };
+      this.dataChannel.onclose = () => {
+        console.log("Opened");
+      };
+    };
+    this.peerConnection.onicecandidate = (event) => {
+      if (event.candidate) {
+        console.log("Send this ICE Candidate to the peer");
+      }
+      if (event.candidate === null) {
+        this.offerSDP = JSON.stringify(this.peerConnection.localDescription);
+        console.log("offerSDP:", this.offerSDP);
+      }
+    };
+    this._fluxWebSocketClientConnection.registerMethod("createOffer", this.createOffer.bind(this));
+    this._fluxWebSocketClientConnection.registerMethod("acceptOffer", this.acceptOffer.bind(this));
+    this._fluxWebSocketClientConnection.registerMethod("acceptAnswer", this.acceptAnswer.bind(this));
+    this._fluxWebSocketClientConnection.registerMethod("answerAcceptedByInitiator", this.answerAcceptedByInitiator.bind(this));
+  }
+  //extends RPCServer<'createOffer' | 'acceptOffer' | 'acceptAnswer'> {
+  peerConnection = new RTCPeerConnection(peerConnectionConfig);
+  dataChannel;
+  //  = this.peerConnection.createDataChannel('flux-channel');
+  offerSDP;
+  /**
+   * This offer must be sent to the other peer.
+   */
+  async createOffer() {
+    console.log("creating offer and data channel");
+    this.dataChannel = this.peerConnection.createDataChannel("flux-channel");
+    this._stateChange("creating-offer");
+    const offer = await this.peerConnection.createOffer();
+    await this.peerConnection.setLocalDescription(offer);
+    console.log("Send this Offer to the peer:", offer);
+    return offer;
+  }
+  /**
+   * 
+   * @param { RTCSessionDescriptionInit } offer 
+   */
+  async acceptOffer(offer) {
+    this._stateChange("setting-remote-offer");
+    await this.peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
+    const answer = await this.peerConnection.createAnswer();
+    this._stateChange("creating-answer");
+    await this.peerConnection.setLocalDescription(answer);
+    console.log("Send this Answer to the peer");
+    return answer;
+  }
+  async acceptAnswer(answer) {
+    this._stateChange("setting-remote-answer");
+    await this.peerConnection.setRemoteDescription(new RTCSessionDescription(answer));
+    this._stateChange("connected");
+    console.log("the answer was accepted");
+    return true;
+  }
+  /**
+   * If remote (not initiator) the answer was accepted.
+   * 
+   * @param answer 
+   * @returns 
+   */
+  answerAcceptedByInitiator(answerAccepted) {
+    this._stateChange(answerAccepted ? "connected" : "failed");
+  }
+  sendMessage(message) {
+    console.log("Sending message over webRTC");
+    if (this.dataChannel && this.dataChannel.readyState === "open") {
+      this.dataChannel.send(message);
+    } else {
+      console.warn("Connection is not established yet.", this.dataChannel?.readyState);
+    }
+  }
+};
+
+// libs/flux/shared/connection/src/lib/agent/flux-agent-network.class.ts
+var FluxAgentNetworkConnection = class {
+  constructor(_fluxWebSocketConnection, _fluxWebSocketClientConnection, _webRTCStateChange) {
+    this._fluxWebSocketConnection = _fluxWebSocketConnection;
+    this._fluxWebSocketClientConnection = _fluxWebSocketClientConnection;
+    this._webRTCStateChange = _webRTCStateChange;
+    if (typeof RTCPeerConnection !== "undefined") {
+      this.iceConnection = new ICEConnection(
+        this._fluxWebSocketClientConnection,
+        this._webRTCStateChange
+      );
+      console.log("RTCPeerConnection is available", !!this.iceConnection);
+    } else {
+      console.warn("\u2757WebRTC is not available in this environment.");
+    }
+  }
+  iceConnection;
+  connectedChannelSet = /* @__PURE__ */ new Set();
+  /**
+   * Joins a channel on the network.
+   * 
+   * @param { string } channelName 
+   */
+  async joinChannel(channelName) {
+    console.log(`Joining channel "${channelName}"`);
+    if (!validateChannelNameOrThrow(channelName)) {
+      throw new Error("This will not actually be thrown");
+    }
+    const fluxNetworkChannel = await this._fluxWebSocketConnection.joinChannel(
+      channelName
+    );
+    this.connectedChannelSet.add(fluxNetworkChannel.channelName);
+    return fluxNetworkChannel;
+  }
+  /**
+   * Listen to messages on this channel.
+   * 
+   * @param { string } channelName
+   * 
+   * @returns { Promise<void> }
+   */
+  async leaveChannel(channelName) {
+    console.log(`Leaving channel "${channelName}"`);
+    if (!validateChannelNameOrThrow(channelName)) {
+      throw new Error("This will not actually be thrown");
+    }
+    await this._fluxWebSocketConnection.leaveChannel(
+      channelName
+    );
+    this.connectedChannelSet.delete(channelName);
+  }
+  /**
+   * Connects to a client.
+   * 
+   * @param clientId
+   * 
+   * @returns 
+   */
+  connectToAgent(clientId) {
+    this._fluxWebSocketConnection.connectToAgent(clientId);
+    return new FluxRemoteClient(this.iceConnection);
+  }
+  readConnectedChannels() {
+    return [...this.connectedChannelSet];
+  }
+};
+
+// libs/flux/shared/connection/src/lib/flux-network-channel.class.ts
+var FluxNetworkChannel = class {
+  constructor(channelName, _fluxWebSocketConnection) {
+    this.channelName = channelName;
+    this._fluxWebSocketConnection = _fluxWebSocketConnection;
+  }
+  /**
+   * Broadcasts a message to the channel.
+   * 
+   * @param { string } channelName
+   * 
+   * @returns { void }
+   */
+  publish(message) {
+    this._fluxWebSocketConnection.publish(
+      this.channelName,
+      message
+    );
+  }
+  /**
+   * Listen to messages on this channel.
+   * 
+   * @param { TMessageCallback } fn
+   * 
+   * @returns { void }
+   */
+  onPublish(fn) {
+    this._fluxWebSocketConnection.onPublish(
+      this.channelName,
+      fn
+      // TODO
+    );
+  }
+};
+
+// libs/flux/shared/types/src/lib/client-id.type.ts
+var NANOID_LENGTH = 21;
+var NANOID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-";
+var isNanoId = (id) => {
+  if (typeof id !== "string") return false;
+  const regex = new RegExp(`^[${NANOID_ALPHABET}]{${NANOID_LENGTH}}$`);
+  return regex.test(id);
+};
+
+// libs/utils/logger/src/lib/utils-logger.ts
+var hasOverlap = (a, b) => a && b ? [...a].some((item) => (Array.isArray(b) ? b : [b]).includes(item)) : false;
+var PicoLogger = /* @__PURE__ */ (() => {
+  let allowScopes;
+  const configure = (configuration) => {
+    allowScopes = typeof configuration.allowScopes === "string" && configuration.allowScopes === "*" ? "*" : new Set(configuration.allowScopes);
+  };
+  const log = (message, scopes) => {
+    if (allowScopes !== "*" && !hasOverlap(allowScopes, scopes)) {
+      return;
+    }
+    console.log(`[${scopes}]	${message}`);
+  };
+  const warn = (message, scopes) => {
+    if (allowScopes !== "*" && !hasOverlap(allowScopes, scopes)) {
+      return;
+    }
+    console.warn(`[${scopes}]	${message}`);
+  };
+  const error = (message, scopes) => {
+    if (allowScopes !== "*" && !hasOverlap(allowScopes, scopes)) {
+      return;
+    }
+    console.error(`[${scopes}]	${message}`);
+  };
+  return {
+    configure,
+    log,
+    warn,
+    error
+  };
+})();
+
+// libs/flux/shared/connection/src/lib/flux-ws-connection.ts
+var createWSConnection = (id, ticket, stateManager, onReconnectCallback, options) => {
+  return new FluxWebSocketConnection(
+    id,
+    onReconnectCallback,
+    stateManager,
+    ticket,
+    options
+  );
+};
+var FluxWebSocketConnection = class {
+  constructor(fluxInstanceId, onReconnectCallback, stateManager, token, options) {
+    this.fluxInstanceId = fluxInstanceId;
+    this.onReconnectCallback = onReconnectCallback;
+    this.stateManager = stateManager;
+    this.token = token;
+    this.options = options;
+    this.options = {
+      // Defaults
+      retries: 1e4,
+      port: 5100,
+      // Override with provided options
+      ...this.options
+    };
+    this.socket = new FluxWebSocketClientConnection(
+      {
+        url: `ws://localhost:${this.options.port}?token=${this.token}`,
+        autoReconnect: true,
+        reconnectDelay: 2e3,
+        retries: this.options.retries
+      }
+    );
+  }
+  socket;
+  callbacks = /* @__PURE__ */ new Set();
+  channelCallbacks = /* @__PURE__ */ new Map();
+  // Handles messages before the rest of the logic. Will not continue if there are interceptors
+  packageTypeInterceptorCallbacks = /* @__PURE__ */ new Map();
+  webSocketClient;
+  first = true;
+  /**
+   * Intercepts messages of a given package type.
+   * 
+   * @param { string }            packageType 
+   * @param { TMessageCallback }  fn
+   * 
+   * @returns { void } 
+   */
+  interceptPackageTypeMessages(packageType, fn) {
+    const existingInterceptors = this.packageTypeInterceptorCallbacks.get(packageType);
+    if (existingInterceptors) {
+      existingInterceptors.add(fn);
+    } else {
+      this.packageTypeInterceptorCallbacks.set(packageType, /* @__PURE__ */ new Set([fn]));
+    }
+  }
+  /**
+   * Removes a package type interceptor.
+   * 
+   * @param { string }            packageType 
+   * @param { TMessageCallback }  fn
+   * 
+   * @returns { void } 
+   */
+  removePackageTypeInterceptor(packageType, fn) {
+    const existingInterceptors = this.packageTypeInterceptorCallbacks.get(packageType);
+    if (existingInterceptors) {
+      existingInterceptors.delete(fn);
+    } else {
+      console.warn(`No interceptors found for package type "${packageType}"`);
+    }
+    if (existingInterceptors && existingInterceptors.size === 0) {
+      this.packageTypeInterceptorCallbacks.delete(packageType);
+    }
+  }
+  /**
+   * Connect to the Flux platform.
+   * 
+   * @returns { Promise<FluxWebSocketClientConnection> }
+   */
+  async connect() {
+    if (this.webSocketClient) {
+      return Promise.resolve(this.webSocketClient);
+    }
+    return new Promise((resolve) => {
+      this.interceptPackageTypeMessages(
+        "isReady",
+        () => {
+          this.stateManager.emitNetworkState("connected");
+          this.webSocketClient = this.socket;
+          resolve(this.socket);
+          if (this.first) {
+            this.first = false;
+            return;
+          }
+          this.onReconnectCallback();
+        }
+      );
+      this.socket.clearEventSubscribers();
+      this.socket.on("message", this.handleMessage.bind(this)).on("close", () => {
+        this.webSocketClient = void 0;
+        this.stateManager.emitNetworkState("disconnected");
+        PicoLogger.log("\u{1F50C}\u{1F534} Disconnected", this.fluxInstanceId);
+      }).on("connecting", (retryAttempt) => {
+        this.stateManager.emitNetworkState("disconnected");
+        if (retryAttempt > 0) {
+          PicoLogger.log(`\u{1F504} Connecting attempt: #${retryAttempt} of ${this.options?.retries ?? "none"}`, this.fluxInstanceId);
+        } else {
+          PicoLogger.log(`\u{1F504} Connecting: ${this.fluxInstanceId}`);
+        }
+      }).on("error", (error) => {
+        PicoLogger.log(`\u274C Error: "${error.message}".`, this.fluxInstanceId);
+      });
+      this.stateManager.emitNetworkState("connecting");
+      this.socket.connect();
+    });
+  }
+  disconnect() {
+    this.socket.close();
+    this.webSocketClient = void 0;
+    this.stateManager.emitNetworkState("disconnected");
+  }
+  /**
+   * Registers an authority to the network.
+   * 
+   * @param { TAuthorizeCallback }        cb
+   * @param { TChannnelAuthCallback<M> }  authorizeNetworkChannel
+   * 
+   * @returns { Promise<void> }
+   */
+  async registerAuthority(cb, authorizeNetworkChannel) {
+    const webSocketClient = await this.connect();
+    webSocketClient.registerMethod("authorize", (messageWithType) => {
+      const dataType = messageWithType.split(":")[0];
+      const message = messageWithType.substring(messageWithType.indexOf(":") + 1);
+      return cb(dataType === "json" ? JSON.parse(message) : message);
+    });
+    webSocketClient.registerMethod("authorizeNetworkChannel", authorizeNetworkChannel);
+    return Promise.resolve(void 0);
+  }
+  /**
+   * Connects to a network.
+   * 
+   * @returns { Promise<FluxAgentNetworkConnection> }
+   */
+  async connectToNetwork() {
+    const webSocketClient = await this.connect();
+    return Promise.resolve(new FluxAgentNetworkConnection(
+      this,
+      webSocketClient,
+      this.stateManager.emitWebRTCState.bind(this.stateManager)
+    ));
+  }
+  /**
+   * Join a channel.
+   * 
+   * @param { TChannelName } channelName
+   * 
+   * @returns { Promise<FluxNetworkChannel> } 
+   */
+  async joinChannel(channelName) {
+    if (this.webSocketClient) {
+      this.webSocketClient.send(`${SUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
+      return new Promise((resolve, reject) => {
+        const cb = (message) => {
+          this.removePackageTypeInterceptor(SUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
+          const receivedChannelName = message.substring(message.indexOf(":") + 1);
+          if (channelName !== receivedChannelName) {
+            reject(new Error(`Channel name mismatch: "${channelName}" !== "${receivedChannelName}"`));
+            return;
+          }
+          resolve(new FluxNetworkChannel(channelName, this));
+        };
+        this.interceptPackageTypeMessages(
+          SUBSCRIBED_NETWORK_CHANNEL_NAME,
+          cb
+        );
+      });
+    }
+    return Promise.reject(new Error("Not connected"));
+  }
+  /**
+   * 
+   * @param { TChannelName } channelName
+   * 
+   * @returns { Promise<void> } 
+   */
+  async leaveChannel(channelName) {
+    if (this.webSocketClient) {
+      this.webSocketClient.send(`${UNSUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
+      return Promise.resolve(void 0);
+    }
+    return Promise.reject(new Error("Not connected"));
+  }
+  /**
+   * 
+   * @param { TChannelName } channelName
+   * @param { string } message
+   * 
+   * @returns { void } 
+   */
+  publish(channelName, message) {
+    if (this.webSocketClient) {
+      const messageString = typeof message === "string" ? message : `o:${JSON.stringify(message)}`;
+      this.webSocketClient.send(`${NETWORK_CHANNEL_PUBLISH}:${channelName}:${messageString}`);
+    }
+  }
+  /**
+   * Adds a callback to the list of callbacks for a given channel topic.
+   * 
+   * @param { TChannelName } channelName
+   * @param { string } message
+   * 
+   * @returns { void } 
+   */
+  onPublish(channelName, fn) {
+    const existingSubscriber = this.channelCallbacks.get(channelName);
+    if (existingSubscriber) {
+      existingSubscriber.add(fn);
+    } else {
+      const newSubscriber = /* @__PURE__ */ new Set();
+      newSubscriber.add(fn);
+      this.channelCallbacks.set(channelName, newSubscriber);
+    }
+  }
+  /**
+   * 
+   * @param { string } channelName
+   * 
+   * @returns { Promise<FluxNetworkChannel> } 
+   */
+  async connectToAgent(destinationClientId) {
+    if (this.webSocketClient) {
+      this.webSocketClient.send(`${CONNECT_TO_CLIENT}:${destinationClientId}`);
+    }
+    return Promise.resolve();
+  }
+  /**
+   * 
+   * @param { TMessageCallback } cb
+   * 
+   * @returns { void } 
+   */
+  onMessage(cb) {
+    this.callbacks.add(cb);
+  }
+  // ****************************************************************************
+  // *** For Authorities
+  // ****************************************************************************
+  /**
+   * Subscribes to the channel changes.
+   * 
+   * @returns { void }
+   */
+  subscribeToChannelChanges() {
+    if (this.webSocketClient) {
+      this.webSocketClient.send(AUTHORITY_CHANNEL_SUBSCRIBE);
+    } else {
+      console.warn("WebSocket client is not connected");
+    }
+  }
+  /**
+   * Disconnects an agent from the network.
+   * 
+   * @param { string } id
+   * 
+   * @returns { void }
+   */
+  disconnectAgent(id) {
+    if (!isNanoId(id)) {
+      throw new Error(`Invalid agent id: '${id}'`);
+    }
+    if (this.webSocketClient) {
+      this.webSocketClient.send(`${AUTHORITY_DISCONNECT_AGENT}:${id}`);
+    } else {
+      console.warn("WebSocket client is not connected");
+    }
+  }
+  // ****************************************************************************
+  // *** Internal Helpers
+  // ****************************************************************************
+  handleMessage(message_) {
+    for (const cb of this.callbacks) {
+      cb(message_);
+    }
+    const packageType = message_.split(":")[0];
+    const msgInterceptors = this.packageTypeInterceptorCallbacks.get(packageType);
+    if (msgInterceptors && msgInterceptors.size > 0) {
+      const channelName = message_.substring(message_.indexOf(":") + 1);
+      for (const msgInterceptor of msgInterceptors) {
+        msgInterceptor(channelName);
+      }
+      return;
+    }
+    switch (packageType) {
+      case ON_NETWORK_CHANNEL_PUBLISH: {
+        const firstColon = message_.indexOf(":");
+        const secondColon = message_.indexOf(":", firstColon + 1);
+        const channelName = message_.slice(firstColon + 1, secondColon);
+        if (validateChannelNameOrThrow(channelName)) {
+          const topicCallbacks = this.channelCallbacks.get(channelName);
+          if (topicCallbacks) {
+            let data = message_.slice(secondColon + 1);
+            if (data.startsWith("o:")) {
+              try {
+                data = JSON.parse(data.substring(2));
+              } catch {
+                data = data.substring(2);
+              }
+            }
+            for (const cb of topicCallbacks) {
+              cb(data);
+            }
+          }
+        }
+        break;
+      }
+      case RPC_REQUEST: {
+        const payload = JSON.parse(message_.substring(message_.indexOf(":") + 1));
+        this.socket.handleMessage(payload, (data) => {
+          this.socket.send(`${RPC_RESPONSE}:${JSON.stringify(data)}`);
+        });
+        break;
+      }
+      case RPC_RESPONSE: {
+        const payload = message_.substring(message_.indexOf(":") + 1);
+        PicoLogger.log("\u{1F50C} Unhandled type rpc response", "ws-client");
+        PicoLogger.log(`payload: ${payload}`, "ws-client");
+        break;
+      }
+      default:
+        PicoLogger.log(`\u{1F50C} Unhandled type: "${message_}"`, "ws-client");
+        break;
+    }
+  }
+};
+
+// packages/flux/agent/src/lib/flux-agent.class.ts
+var import_nanoid = require("nanoid");
+
+// packages/flux/agent/src/lib/utils/obscuring/shared.utils.ts
+var ALGORITHM = { name: "AES-GCM", length: 256 };
+var PBKDF2_ITERATIONS = 1e5;
+async function deriveKey(password, salt) {
+  const passwordBuffer = new TextEncoder().encode(password);
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    passwordBuffer,
+    { name: "PBKDF2" },
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations: PBKDF2_ITERATIONS,
+      hash: "SHA-256"
+    },
+    keyMaterial,
+    ALGORITHM,
+    true,
+    ["encrypt", "decrypt"]
+  );
 }
-console.log("Hello from persistica-flux-agent!");
+
+// packages/flux/agent/src/lib/utils/obscuring/encyprt.utils.ts
+var IV_LENGTH = 12;
+var SALT_LENGTH = 16;
+async function encrypt(data, password) {
+  const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+  const key = await deriveKey(password, salt);
+  const encoded = new TextEncoder().encode(data);
+  const encryptedBuffer = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    encoded
+  );
+  return {
+    encrypted: btoa(String.fromCharCode(...new Uint8Array(encryptedBuffer))),
+    // Base64
+    iv: btoa(String.fromCharCode(...iv)),
+    // Base64 IV
+    salt: btoa(String.fromCharCode(...salt))
+    // Base64 Salt
+  };
+}
+
+// libs/flux/shared/utils/src/lib/state-manager.util.ts
+var StateManager = class {
+  networkStateListeners = /* @__PURE__ */ new Set();
+  webRTCStateListeners = /* @__PURE__ */ new Set();
+  attachNetworkStateListener(fn) {
+    this.networkStateListeners.add(fn);
+  }
+  detachNetworkStateListener(fn) {
+    this.networkStateListeners.delete(fn);
+  }
+  attachWebRTCStateListener(fn) {
+    this.webRTCStateListeners.add(fn);
+  }
+  detachWebRTCStateListener(fn) {
+    this.webRTCStateListeners.delete(fn);
+  }
+  emitNetworkState(networkState) {
+    for (const fn of this.networkStateListeners) {
+      fn(networkState);
+    }
+  }
+  emitWebRTCState(rtcState) {
+    for (const fn of this.webRTCStateListeners) {
+      fn(rtcState);
+    }
+  }
+  /*
+      public clear(
+  
+      ): void {
+          this.networkStateListeners.clear();
+          this.webRTCStateListeners.clear();
+      }
+  
+      public getNetworkStateListeners(
+  
+      ): Set<(networkState: TNetworkConnectionState) => void> {
+          return this.networkStateListeners;
+      }
+  
+      public getWebRTCStateListeners(
+  
+      ): Set<(rtcState: TRTCState) => void> {
+          return this.webRTCStateListeners;
+      }
+  
+      public getNetworkStateListenersCount(
+  
+      ): number {
+          return this.networkStateListeners.size;
+      }
+  
+      public getWebRTCStateListenersCount(
+  
+      ): number {
+          return this.webRTCStateListeners.size;
+      }
+   */
+};
+
+// libs/flux/shared/utils/src/lib/machine-id.util.ts
+var validateMachineUID = (machineUID) => {
+  if (typeof machineUID !== "string") {
+    console.warn("Machine UID must be a string");
+    return false;
+  }
+  if (machineUID.length < 5) {
+    console.warn("Machine UID too short");
+    return false;
+  }
+  if (machineUID.length > 50) {
+    console.warn("Machine UID too long");
+    return false;
+  }
+  return true;
+};
+var getMachineUID = async () => {
+  if (typeof globalThis !== "object") {
+    throw new Error("Flux can only be used in an environment with globalThis");
+  }
+  if (globalThis.__flux_client_id !== null) {
+    console.log("[flux-client] Reusing existing id");
+    return globalThis.__flux_client_id;
+  }
+  globalThis.__flux_client_id = null;
+  return globalThis.__flux_client_id;
+};
+
+// packages/flux/agent/src/lib/connector/auth/register-client.auth.ts
+var authenticateAgentOrThrow = async (networkId, domain, unknownIdentificationPayload, clientInfo, password) => {
+  if (unknownIdentificationPayload === void 0 || unknownIdentificationPayload === null) {
+    throw new Error("Custom payload is required");
+  }
+  let customPayload;
+  if (typeof unknownIdentificationPayload === "string") {
+    customPayload = unknownIdentificationPayload;
+  }
+  if (typeof unknownIdentificationPayload === "object") {
+    try {
+      customPayload = JSON.stringify(unknownIdentificationPayload);
+    } catch {
+      throw new Error("Custom payload must be serializable");
+    }
+  }
+  if (customPayload === void 0) {
+    throw new Error("Custom payload must be a string or serializable object");
+  }
+  if (password !== void 0) {
+    customPayload = JSON.stringify(await encrypt(customPayload, password));
+  }
+  const url = new URL(`${domain}/auth/network-client`);
+  url.searchParams.set("networkId", networkId);
+  if (clientInfo.clientUId) {
+    url.searchParams.set("requestedAgentUid", clientInfo.clientUId);
+  }
+  if (clientInfo.machineUID && validateMachineUID(clientInfo.machineUID)) {
+    url.searchParams.set("machineUID", clientInfo.machineUID);
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "text/plain",
+      "x-flux-content-type": typeof unknownIdentificationPayload === "string" ? "text/plain" : "application/json",
+      "Accept": "text/plain"
+    },
+    body: customPayload
+  });
+  if (!response.ok) {
+    throw new Error(`Auth failed: ${response.status}`);
+  }
+  const result = await response.text();
+  if (!checkAuthTicketShape(result)) {
+    throw new Error("Auth failed: unexpected response");
+  }
+  return result;
+};
+
+// packages/flux/agent/src/lib/connector/flux-client-data.class.ts
+var FluxClientData = class {
+  callbacks = /* @__PURE__ */ new Set();
+  fluxWebSocketConnection;
+  updateWsConnection(fluxWebSocketConnection) {
+    this.fluxWebSocketConnection = fluxWebSocketConnection;
+    for (const cb of this.callbacks) {
+      this.fluxWebSocketConnection.onMessage(cb);
+    }
+  }
+  onMessage(cb) {
+    this.callbacks.add(cb);
+  }
+};
+
+// packages/flux/agent/src/lib/flux-agent.class.ts
+globalThis.agentLoadCount ??= 0;
+globalThis.agentLoadCount++;
+console.log(`[flux-agent] Reloaded ${globalThis.agentLoadCount} time(s)`);
+var FluxAgent = class {
+  constructor(networkId, options) {
+    this.networkId = networkId;
+    this.options = options;
+  }
+  id = (0, import_nanoid.nanoid)();
+  fluxWebSocketConnection;
+  fluxClientData = new FluxClientData();
+  stateManager = new StateManager();
+  /**
+   * Connect to the network using provided identification.
+   * 
+   * @param { unknown }   identification
+   * @param { string }    [clientUId]
+   *
+   * @returns { Promise<FluxAgentNetworkConnection> }
+   */
+  async connect(identification, clientUId) {
+    this.stateManager.emitNetworkState("authorizing");
+    if (clientUId && !validateAgentUIDOrThrow(clientUId)) {
+      throw new Error("Will never be thrown");
+    }
+    const ticket = await authenticateAgentOrThrow(
+      this.networkId,
+      this.options?.domain ?? "http://localhost:5100",
+      identification,
+      {
+        clientUId,
+        machineUID: await getMachineUID() ?? void 0
+      }
+    );
+    this.fluxWebSocketConnection = createWSConnection(
+      this.id,
+      ticket,
+      this.stateManager,
+      async () => {
+        await this.connect(
+          identification,
+          clientUId
+        );
+      },
+      this.options
+    );
+    this.fluxClientData.updateWsConnection(this.fluxWebSocketConnection);
+    const fluxNetworkConnection = await this.fluxWebSocketConnection.connectToNetwork();
+    return fluxNetworkConnection;
+  }
+  disconnect() {
+    this.fluxWebSocketConnection?.disconnect();
+  }
+  /**
+   *
+   * @param fn
+   *
+   * @returns { void }
+   */
+  onWebRTConnectionState = this.stateManager.attachWebRTCStateListener.bind(this.stateManager);
+  /**
+   *
+   * @param fn
+   *
+   * @returns { void }
+   */
+  onNetworkState = this.stateManager.attachNetworkStateListener.bind(this.stateManager);
+  onMessage(cb) {
+    this.fluxClientData.onMessage(cb);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  persisticaFluxAgent2
+  FluxAgent
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@persistica/flux-agent",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Persistica Flux Agent",
   "type": "module",
   "keywords": [],
@@ -9,7 +9,6 @@
   },
   "main": "./index.cjs",
   "types": "./index.d.ts",
-  "dependencies": {},
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rujorgensen/persistica.git"
@@ -20,5 +19,9 @@
     "url": "https://github.com/rujorgensen/persistica/issues"
   },
   "homepage": "https://github.com/rujorgensen/persistica#readme",
+  "dependencies": {
+    "nanoid": "5.1.5"
+  },
+  "packageManager": "bun@1.2.20",
   "module": "./index.js"
 }

package/src/index.d.ts

@@ -1 +1 @@
-export * from './lib/persistica-flux-agent-2';
+export { FluxAgent, } from './lib/flux-agent.class';

package/src/lib/channel/channel.type.d.ts

@@ -0,0 +1,10 @@
+import type { TChannelName } from '@flux/shared/types';
+/**
+ * Callback function to authorize a channel connection.
+ *
+ * @param { TChannelName }     channelTopic - the topic to subscribe to
+ * @param { unknown }           identification - whatever identification the authority requires
+ *
+ * @returns { Promise<boolean> } - true if the channel connection is authorized, false otherwise
+ */
+export type TChannnelAuthCallback<T> = (channelTopic: TChannelName, identification: T) => Promise<boolean>;

package/src/lib/connector/auth/register-client.auth.d.ts

@@ -0,0 +1,18 @@
+import { type TAuthenticationTicket, type TAgentOwnUId, type TNetworkId_S } from '@flux/shared/types';
+import { type TFluxClientUID } from '@flux/shared/utils';
+/**
+ * Authenticates with the server and returns a ticket for connecting the websocket.
+ *
+ * This client -> flux server -> authority client -> flux server -> this client.
+ *
+ * @param { string }        domain The domain of the authority server.
+ * @param { unknown }       unknownIdentificationPayload The payload to send to the authority server.
+ * @param { string }        [password]
+ * @param { TAgentOwnUId }  [agentOwnUId]
+ *
+ * @returns { Promise<TAuthenticationTicket> }
+ */
+export declare const authenticateAgentOrThrow: (networkId: TNetworkId_S, domain: string, unknownIdentificationPayload: unknown, clientInfo: {
+    clientUId?: TAgentOwnUId;
+    machineUID?: TFluxClientUID;
+}, password?: string) => Promise<TAuthenticationTicket>;

package/src/lib/connector/flux-client-data.class.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Collects data from any source (currently WS or WebRTC)
+ */
+import type { TMessageCallback } from '@flux/shared/ws';
+import type { FluxWebSocketConnection } from '@flux/shared/connection';
+export declare class FluxClientData {
+    private readonly callbacks;
+    private fluxWebSocketConnection;
+    updateWsConnection(fluxWebSocketConnection: FluxWebSocketConnection): void;
+    onMessage(cb: TMessageCallback): void;
+}

package/src/lib/connector/low-level-com/web-rtc/ice-connection.d.ts

@@ -0,0 +1,34 @@
+/**
+ * One device calls createOffer() and shares the generated offer with the second device.
+ * The second device calls acceptOffer(offer), generates an answer, and shares it back with the first device.
+ * Both devices exchange ICE candidates (logged in the console) to establish the P2P connection.
+ * Once connected, messages can be sent between devices.
+ */
+import type { TRTCState } from '@flux/shared/utils';
+import type { FluxWebSocketClientConnection } from '@flux/shared/ws';
+export declare class ICEConnection {
+    private readonly _fluxWebSocketClientConnection;
+    private readonly _stateChange;
+    private readonly peerConnection;
+    private dataChannel;
+    private offerSDP;
+    constructor(_fluxWebSocketClientConnection: FluxWebSocketClientConnection, _stateChange: (state: TRTCState) => void);
+    /**
+     * This offer must be sent to the other peer.
+     */
+    private createOffer;
+    /**
+     *
+     * @param { RTCSessionDescriptionInit } offer
+     */
+    private acceptOffer;
+    private acceptAnswer;
+    /**
+     * If remote (not initiator) the answer was accepted.
+     *
+     * @param answer
+     * @returns
+     */
+    private answerAcceptedByInitiator;
+    sendMessage(message: string): void;
+}

package/src/lib/connector/rpc/NOT-USED-network-authority.class.d.ts

@@ -0,0 +1,4 @@
+import { RPCServer } from '@flux/shared/ws';
+export declare class AuthorityClient extends RPCServer<'authorize'> {
+    authorize(fn: (jwt: unknown) => boolean): void;
+}

package/src/lib/connector/state-machines/connect-to-remote-client.d.ts

@@ -0,0 +1,6 @@
+import { RPCServer } from '@flux/shared/ws';
+export declare class ConnectToRemoteClient extends RPCServer<'createOffer' | 'acceptOffer'> {
+    private peerConnection;
+    private dataChannel;
+    constructor();
+}

package/src/lib/flux-agent.class.d.ts

@@ -0,0 +1,43 @@
+declare global {
+    var agentLoadCount: number | null | undefined;
+}
+import type { TMessageCallback } from '@flux/shared/ws';
+import type { FluxAgentNetworkConnection } from '@flux/shared/connection';
+export declare class FluxAgent {
+    private readonly networkId;
+    private readonly options?;
+    readonly id: string;
+    private fluxWebSocketConnection;
+    private readonly fluxClientData;
+    private readonly stateManager;
+    constructor(networkId: string, options?: {
+        domain?: string;
+        secretKey?: string;
+        retries?: number;
+    } | undefined);
+    /**
+     * Connect to the network using provided identification.
+     *
+     * @param { unknown }   identification
+     * @param { string }    [clientUId]
+     *
+     * @returns { Promise<FluxAgentNetworkConnection> }
+     */
+    connect(identification: unknown, clientUId?: string): Promise<FluxAgentNetworkConnection>;
+    disconnect(): void;
+    /**
+     *
+     * @param fn
+     *
+     * @returns { void }
+     */
+    onWebRTConnectionState: (fn: (rtcState: import("@flux/shared/utils").TRTCState) => void) => void;
+    /**
+     *
+     * @param fn
+     *
+     * @returns { void }
+     */
+    onNetworkState: (fn: (networkState: import("@flux/shared/utils").TNetworkConnectionState) => void) => void;
+    onMessage(cb: TMessageCallback): void;
+}

package/src/lib/flux-interface.class.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Interface to the flux platform:
+ *
+ * Requires socket connectivity to the Flux platform, and a verified network.
+ */
+import type { IPackageStatus } from '@flux/shared/types';
+import type { FluxWebSocketConnection } from '../../../../../libs/flux/shared/connection/src/lib/flux-ws-connection';
+export declare class FluxInterface {
+    private readonly socketConnection;
+    constructor(socketConnection: FluxWebSocketConnection);
+    messageReport(packageStatus: Omit<IPackageStatus, 'txNode'>): void;
+}

package/src/lib/flux-remote-client.class.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A connection to another known client
+ */
+import { ICEConnection } from './connector/low-level-com/web-rtc/ice-connection';
+export declare class FluxRemoteClient {
+    private readonly iceConnection;
+    constructor(iceConnection: ICEConnection);
+    callProcedure(): void;
+    send(message: string): void;
+}

package/src/lib/route-transport-coordinator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Coordinate the route transport of messages.
+ *
+ * Requires connectivity to the Flux platform, and a network.
+ */
+export declare class RouteCoordinator {
+    constructor(fluxInterface: any);
+}

package/src/lib/utils/obscuring/decrypt.utils.d.ts

@@ -0,0 +1,13 @@
+interface IEncryptedData {
+    encrypted: string;
+    iv: string;
+    salt: string;
+}
+/**
+ * Decrypts an AES-256-GCM encrypted JSON object using a password
+ * @param {IEncryptedData} encryptedData - The encrypted data object
+ * @param {string} password - The password
+ * @returns {Promise<Object>} - Decrypted JSON object
+ */
+export declare function decrypt(encryptedData: IEncryptedData, password: string): Promise<any>;
+export {};

package/src/lib/utils/obscuring/encyprt.utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Encrypts a JSON object using AES-256-GCM with password-derived key
+ *
+ * @param {Object} data - The data to encrypt
+ * @param {string} password - The password
+ * @returns {Promise<Object>} - Encrypted data (Base64 format)
+ */
+export declare function encrypt(data: string, password: string): Promise<{
+    encrypted: string;
+    iv: string;
+    salt: string;
+}>;

package/src/lib/utils/obscuring/shared.utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Derive a cryptographic key from a password using PBKDF2
+ *
+ * @param { string } password - User-provided password
+ * @param { Uint8Array } salt - Salt for key derivation
+ *
+ * @returns { Promise<CryptoKey> } - AES-256-GCM key
+ */
+export declare function deriveKey(password: string, salt: any): Promise<CryptoKey>;

package/src/lib/persistica-flux-agent-2.d.ts

@@ -1 +0,0 @@
-export declare function persisticaFluxAgent2(): string;