@persistica/flux-agent 0.0.1 → 0.0.6

package/package.json

@@ -1,24 +1,23 @@
 {
-  "name": "@persistica/flux-agent",
-  "version": "0.0.1",
-  "description": "Persistica Flux Agent",
-  "type": "module",
-  "keywords": [],
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "./index.cjs",
-  "types": "./index.d.ts",
-  "dependencies": {},
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/rujorgensen/persistica.git"
-  },
-  "author": "pixl.prophet",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/rujorgensen/persistica/issues"
-  },
-  "homepage": "https://github.com/rujorgensen/persistica#readme",
-  "module": "./index.js"
+    "name": "@persistica/flux-agent",
+    "version": "0.0.6",
+    "description": "Persistica Flux Agent",
+    "type": "module",
+    "keywords": [],
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": "./index.js",
+    "main": "./index.js",
+    "types": "./src/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/rujorgensen/persistica.git"
+    },
+    "author": "pixl.prophet",
+    "license": "ISC",
+    "bugs": {
+        "url": "https://github.com/rujorgensen/persistica/issues"
+    },
+    "homepage": "https://github.com/rujorgensen/persistica#readme"
 }

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/index.cjs

@@ -1,35 +0,0 @@
-"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);
-
-// packages/flux/agent-2/src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  persisticaFluxAgent2: () => persisticaFluxAgent2
-});
-module.exports = __toCommonJS(src_exports);
-
-// packages/flux/agent-2/src/lib/persistica-flux-agent-2.ts
-function persisticaFluxAgent2() {
-  return "persistica-flux-agent-2";
-}
-console.log("Hello from persistica-flux-agent!");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  persisticaFluxAgent2
-});

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

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