@persistica/flux-mesh 0.0.26 → 0.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@persistica/flux-mesh",
-    "version": "0.0.26",
+    "version": "0.0.28",
     "description": "Persistica Flux Mesh",
     "type": "module",
     "keywords": [],

package/src/_managers/agent.manager.d.ts

@@ -1,15 +1,15 @@
 import { type TAddress, type TClientId } from '@flux/shared/types';
 import { RedisConnection } from '../routing/redis/redis-connection.class';
 import { TConnectedClientSocket } from '../connected-client-socket.types';
-import { NetworkAgentRedisCache } from '../register/network-agent-redis-cache.class';
+import { NetworkAgentService } from '../register/network-agent.service';
 export declare class AgentManager {
     private readonly _redisConnection;
     private readonly _clientMap;
-    private readonly _networkAgentRedisCache;
+    private readonly _networkAgentService;
     private readonly machineAddress;
     private readonly processAddress;
     private readonly _globalClientManager;
     private readonly _localAgentManager;
-    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentRedisCache: NetworkAgentRedisCache);
+    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentService: NetworkAgentService);
     kick(agentAddress: TAddress): void;
 }

package/src/_managers/authority.manager.d.ts

@@ -1,7 +1,7 @@
 import { type TAddress, type TClientId } from '@flux/shared/types';
 import { RedisConnection } from '../routing/redis/redis-connection.class';
 import { TConnectedClientSocket } from '../connected-client-socket.types';
-import { NetworkAuthorityRedisCache } from '../register/network-authority-redis-cache.class';
+import { NetworkAuthorityCache } from '../register/network-authority-cache.class';
 export declare class AuthorityManager {
     private readonly _redisConnection;
     private readonly _clientMap;
@@ -10,6 +10,6 @@ export declare class AuthorityManager {
     private readonly processAddress;
     private readonly _globalClientManager;
     private readonly _localAuthorityManager;
-    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityRedisCache);
+    constructor(_redisConnection: RedisConnection, _clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityCache);
     kick(authorityAddress: TAddress): void;
 }

package/src/_managers/global/global-client.manager.d.ts

@@ -8,6 +8,8 @@ import { RedisConnection } from '../../routing/redis/redis-connection.class';
 export declare class GlobalClientManager {
     private readonly _redisConnection;
     private readonly processAddress;
+    private readonly networkAgentRedisService;
+    private readonly networkAuthorityRedisService;
     constructor(_redisConnection: RedisConnection);
     /**
      * Sends a global message to kick a client.

package/src/_managers/local/local-agent.manager.d.ts

@@ -3,10 +3,10 @@
  */
 import type { TClientId } from '@flux/shared/types';
 import { TConnectedClientSocket } from '../../connected-client-socket.types';
-import { NetworkAgentRedisCache } from '../../register/network-agent-redis-cache.class';
+import { NetworkAgentService } from '../../register/network-agent.service';
 export declare class LocalAgentManager {
     private readonly _clientMap;
-    private readonly _networkAgentRedisCache;
-    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentRedisCache: NetworkAgentRedisCache);
+    private readonly _networkAgentService;
+    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAgentService: NetworkAgentService);
     kickAgent(clientId: TClientId): Promise<void>;
 }

package/src/_managers/local/local-authority.manager.d.ts

@@ -3,10 +3,10 @@
  */
 import type { TClientId } from '@flux/shared/types';
 import type { TConnectedClientSocket } from '../../connected-client-socket.types';
-import { NetworkAuthorityRedisCache } from '../../register/network-authority-redis-cache.class';
+import { NetworkAuthorityCache } from '../../register/network-authority-cache.class';
 export declare class LocalAuthorityManager {
     private readonly _clientMap;
     private readonly _networkAuthorityRedisCache;
-    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityRedisCache);
+    constructor(_clientMap: Map<TClientId, TConnectedClientSocket>, _networkAuthorityRedisCache: NetworkAuthorityCache);
     kickAuthority(clientId: TClientId): Promise<void>;
 }

package/src/_routes/auth/network-client.post.route.d.ts

@@ -1,13 +1,13 @@
 import type { BunRequest } from 'bun';
 import type { GlobalRPCClient } from '../../routing/rpc/core/global-rpc-client.class';
-import type { NetworkAuthorityRedisCache } from '../../register/network-authority-redis-cache.class';
+import type { NetworkAuthorityCache } from '../../register/network-authority-cache.class';
 /**
  * This route is used to authorize an agent connection.
  *
  * @param { BunRequest } request - The incoming HTTP request
- * @param { NetworkAuthorityRedisCache } networkAuthorityManager - The network authority manager
+ * @param { NetworkAuthorityCache } networkAuthorityManager - The network authority manager
  * @param { GlobalRPCClient<'authorizeAgentConnection'> } globalRPCClient - The global RPC client
  *
  * @returns { Promise<Response> } The HTTP response with auth token or error
  */
-export declare const authorizeAgentConnection: (request: BunRequest, networkAuthorityManager: NetworkAuthorityRedisCache, globalRPCClient: GlobalRPCClient<"authorizeAgentConnection">) => Promise<Response>;
+export declare const authorizeAgentConnection: (request: BunRequest, networkAuthorityManager: NetworkAuthorityCache, globalRPCClient: GlobalRPCClient<"authorizeAgentConnection">) => Promise<Response>;

package/src/_ws-handlers/ws-socket-close.d.ts

@@ -0,0 +1,4 @@
+import { TConnectedClientSocket } from '../connected-client-socket.types';
+import { NetworkAuthorityCache } from '../register/network-authority-cache.class';
+import { NetworkAgentService } from '../register/network-agent.service';
+export declare const onSocketClosed: (clientMap: Map<string, TConnectedClientSocket>, networkAuthorityRedisCache: NetworkAuthorityCache, networkAgentService: () => NetworkAgentService) => (ws: TConnectedClientSocket, code: number) => Promise<void>;

package/src/business-logic/channels/channel-manager.class.d.ts

@@ -1,19 +1,10 @@
-import { type TAddress, type TChannelName, type TNetworkId_S, type TSubscription_S } from '@flux/shared/types';
+import { type TAddress, type TChannelName, type TNetworkId_S, type TSubscription_S, type TClientId } from '@flux/shared/types';
 import type { GlobalChannelPubsub } from '../../routing/global-channel/global-channel-pubsub.class';
-export declare const MAX_CHANNEL_MEMBERS_BY_SUBSCRIPTION_TYPE: {
-    [key in TSubscription_S]: number;
-};
-export declare const MAX_CHANNEL_MEMBERS: number;
-export declare const normalizeSubscriptionType: (subscriptionType?: unknown) => TSubscription_S | undefined;
-export declare const resolveSubscriptionTypeOrDefault: (subscriptionType?: unknown) => TSubscription_S;
-export declare const readMaxChannelMembers: (subscriptionType?: unknown) => number;
-export declare const readSubscriptionTypeFromClaim: (claim?: unknown) => TSubscription_S | undefined;
-export declare const canChannelHaveMoreMembers: (memberCount: number, subscriptionType?: TSubscription_S) => boolean;
 export declare class NetworkChannelManager {
     private readonly _globalChannelPubsub;
     private readonly channelUsageCount;
     private readonly redisConnection;
-    private readonly networkChannelHash;
+    private readonly networkChannelService;
     constructor(_globalChannelPubsub: GlobalChannelPubsub);
     /**
      * Checks if a channel can have more members.
@@ -33,12 +24,13 @@ export declare class NetworkChannelManager {
      * Leaves all network channels.
      */
     leaveAllNetworkChannels(networkId: TNetworkId_S, clientAddress: TAddress, channelNames: Set<TChannelName>): Promise<void>;
-    /**
-     * Creates a network channel if it does not exist.
-     */
-    private createNetworkChannelIfNotExist;
+    readChannelNamesForClientId(networkId: TNetworkId_S, clientId: TClientId): Promise<Set<TChannelName>>;
     /**
      * Increases the usage count of a channel.
      */
     increaseUsageCount(networkId: TNetworkId_S, channelName: TChannelName, usage: number): void;
+    /**
+     * Creates a network channel if it does not exist.
+     */
+    private createNetworkChannelIfNotExist;
 }

package/src/business-logic/channels/channel-manager.utils.d.ts

@@ -0,0 +1,4 @@
+import type { TSubscription_S } from '@flux/shared/types';
+export declare const resolveSubscriptionTypeOrDefault: (subscriptionType?: unknown) => TSubscription_S;
+export declare const readSubscriptionTypeFromClaim: (claim?: unknown) => TSubscription_S | undefined;
+export declare const canChannelHaveMoreMembers: (memberCount: number, subscriptionType?: TSubscription_S) => boolean;

package/src/business-logic/processes/process.class.d.ts

@@ -0,0 +1,24 @@
+import { type TProcessAddress, type TMachineAddress } from '@flux/shared/types';
+import { RedisConnection } from '../../routing/redis/redis-connection.class';
+import { NetworkAgentService } from '../../register/network-agent.service';
+export declare class ProcessClass {
+    private readonly _redisConnection;
+    private readonly _networkAgentService;
+    constructor(_redisConnection: RedisConnection, _networkAgentService: NetworkAgentService);
+    /**
+     *
+     */
+    cleanupOrphans(machineAddress: TMachineAddress): Promise<void>;
+    /**
+     * Marks the given address as connected in Redis.
+     */
+    setConnected(processAddress: TProcessAddress): Promise<void>;
+    /**
+     * Marks the given address as disconnected in Redis.
+     */
+    setDisconnected(processAddress: TProcessAddress): Promise<void>;
+    /**
+     * Returns up to 3 lost processes while prioritizing ones that have been running on this machine, and oldest.
+     */
+    private readDisconnectedAddresses;
+}

package/src/main.d.ts

@@ -12,6 +12,8 @@ export declare class FluxMeshServer {
     private readonly globalChannelPubsub;
     private readonly channelManager;
     private readonly agentManager;
+    private readonly processClass;
+    private readonly networkAgentService;
     constructor(optionsOrPort?: (TOptions | number) | undefined);
     onReady(fn: () => void): void;
     /**

package/src/register/network-agent-redis-cache.class.d.ts

@@ -1,4 +1,4 @@
-import type { NetworkAgentRedisService } from '@flux/mesh/store/redis/network-agent';
+import { NetworkAgentRedisService } from '@flux/mesh/store/redis/network-agent';
 import { NetworkUsageRedisCacheService } from '@flux/mesh/store/redis/network-usage';
 import type { TAddress, TClientId, TAgentOwnUId, TNetworkId_S } from '@flux/shared/types';
 import type { TFluxClientUID } from '@flux/shared/utils';
@@ -13,7 +13,7 @@ export declare class NetworkAgentRedisCache {
      * Register an agent.
      *
      * @param { TNetworkId_S } networkId - The network ID
-     * @param { TClientId } id - The client socket ID
+     * @param { TClientId } clientId - The client socket ID
      * @param { Bun.SocketAddress | null } ip - The client IP address
      * @param { TAddress } address - The client address
      * @param { object } throughput - The throughput tracking object
@@ -22,7 +22,7 @@ export declare class NetworkAgentRedisCache {
      *
      * @returns { Promise<void> }
      */
-    registerAgent(networkId: TNetworkId_S, id: TClientId, ip: Bun.SocketAddress | null, address: TAddress, throughput: {
+    registerAgent(networkId: TNetworkId_S, clientId: TClientId, ip: Bun.SocketAddress | null, address: TAddress, throughput: {
         bytes: number;
         packets: number;
     }, uid?: TAgentOwnUId, machineUID?: TFluxClientUID): Promise<void>;

package/src/register/network-agent.service.d.ts

@@ -0,0 +1,30 @@
+import type { TAddress, TClientId, TAgentOwnUId, TNetworkId_S, TChannelName } from '@flux/shared/types';
+import type { TFluxClientUID } from '@flux/shared/utils';
+import { NetworkAgentRedisCache } from './network-agent-redis-cache.class';
+import { NetworkChannelManager } from '../business-logic/channels/channel-manager.class';
+import { RedisConnection } from '../routing/redis/redis-connection.class';
+export declare class NetworkAgentService {
+    private readonly networkAgentRedisCache;
+    private readonly redisConnection;
+    private readonly networkChannelManager;
+    private readonly networkAgentRedisRepository;
+    constructor(networkAgentRedisCache: NetworkAgentRedisCache, redisConnection: RedisConnection, networkChannelManager: NetworkChannelManager);
+    /**
+     * Register an agent.
+     */
+    registerAgent(networkId: TNetworkId_S, clientId: TClientId, ip: Bun.SocketAddress | null, address: TAddress, throughput: {
+        bytes: number;
+        packets: number;
+    }, uid?: TAgentOwnUId, machineUID?: TFluxClientUID): Promise<void>;
+    /**
+     * Unregisters a network agent UID and associated data from the Redis hash.
+     */
+    unregister(clientId: TClientId, clientAddress?: TAddress, networkId?: TNetworkId_S, networkChannels?: Set<TChannelName>, clientOwnUId?: {
+        clientOwnUId: TAgentOwnUId;
+        networkId: TNetworkId_S;
+    }): Promise<void>;
+    /**
+     * Resolves the network client address by an agent's UID, using a local cache to avoid unnecessary Redis calls.
+     */
+    resolveClientAddressByUid(networkId: TNetworkId_S, clientOwnUId: TAgentOwnUId): Promise<TAddress>;
+}

package/src/register/{network-authority-redis-cache.class.d.ts → network-authority-cache.class.d.ts}

@@ -1,6 +1,6 @@
 import { type TAddress, type TClientId, type TNetworkId_S } from '@flux/shared/types';
 import type { TFluxClientUID } from '@flux/shared/utils';
-export declare class NetworkAuthorityRedisCache {
+export declare class NetworkAuthorityCache {
     private readonly redisConnection;
     private readonly cache;
     private readonly clientCache;
@@ -9,11 +9,12 @@ export declare class NetworkAuthorityRedisCache {
      *
      * @param { TNetworkId_S } networkId - The network ID to register on
      * @param { TClientId } clientId - The socket ID of the authority
+     * @param { Bun.SocketAddress | null } ip - The client IP address
      * @param { TFluxClientUID } [machineUID] - Optional machine UID
      *
      * @returns { Promise<void> }
      */
-    register(networkId: TNetworkId_S, clientId: TClientId, machineUID?: TFluxClientUID): Promise<void>;
+    register(networkId: TNetworkId_S, clientId: TClientId, ip: Bun.SocketAddress | null, machineUID?: TFluxClientUID): Promise<void>;
     /**
      * Unregisters a network authority from the local network.
      *

package/src/routing/redis/redis-connection.class.d.ts

@@ -1,6 +1,4 @@
 import type { TAddress, TClientId, TNetworkId_S, TNetworkToken_S, TProcessAddress } from '@flux/shared/types';
-import { NetworkAuthorityRedisSortedSet } from '@flux/mesh/store/redis/network-authority';
-import { NetworkAgentRedisService } from '@flux/mesh/store/redis/network-agent';
 import type { TGlobalChannel } from '../global-channel/global-channel-pubsub.class';
 /**
  * Singleton function to get the Redis connection.
@@ -12,17 +10,16 @@ import type { TGlobalChannel } from '../global-channel/global-channel-pubsub.cla
 export declare const getMeshRedisConnection: (_connectionString?: string) => RedisConnection;
 export type MessageCallback = (message: string, channel?: string) => unknown;
 export declare class RedisConnection {
-    private readonly _optionsOrURL;
     private readonly cacheClient;
     private readonly pubSub;
-    readonly networkAuthoritySet: NetworkAuthorityRedisSortedSet;
-    readonly networkAgentRedisService: NetworkAgentRedisService;
     readonly hash: {
         sadd: (key: Bun.RedisClient.KeyLike, ...members: string[]) => Promise<number>;
         hset: {
             (key: Bun.RedisClient.KeyLike, fields: Record<string | number, Bun.RedisClient.KeyLike | number>): Promise<number>;
             (key: Bun.RedisClient.KeyLike, field: Bun.RedisClient.KeyLike, value: Bun.RedisClient.KeyLike, ...rest: Bun.RedisClient.KeyLike[]): Promise<number>;
         };
+        hget: (key: Bun.RedisClient.KeyLike, field: Bun.RedisClient.KeyLike) => Promise<string | null>;
+        hdel: (key: Bun.RedisClient.KeyLike, field: Bun.RedisClient.KeyLike, ...rest: Bun.RedisClient.KeyLike[]) => Promise<number>;
         smembers: (key: Bun.RedisClient.KeyLike) => Promise<string[]>;
         srem: (key: Bun.RedisClient.KeyLike, ...members: string[]) => Promise<number>;
         scard: (key: Bun.RedisClient.KeyLike) => Promise<number>;
@@ -34,7 +31,25 @@ export declare class RedisConnection {
         };
         expire: (key: Bun.RedisClient.KeyLike, seconds: number) => Promise<number>;
     };
-    constructor(_optionsOrURL: string | {
+    readonly sortedSet: {
+        zadd: (key: Bun.RedisClient.KeyLike, ...args: (string | number)[]) => Promise<number>;
+        zrem: (key: Bun.RedisClient.KeyLike, member: Bun.RedisClient.KeyLike, ...members: Bun.RedisClient.KeyLike[]) => Promise<number>;
+        zscore: (key: Bun.RedisClient.KeyLike, member: string) => Promise<number | null>;
+        zrangebylex: {
+            (key: Bun.RedisClient.KeyLike, min: string, max: string): Promise<string[]>;
+            (key: Bun.RedisClient.KeyLike, min: string, max: string, limit: "LIMIT", offset: number, count: number): Promise<string[]>;
+            (key: Bun.RedisClient.KeyLike, min: string, max: string, ...options: (string | number)[]): Promise<string[]>;
+        };
+        zrangebyscore: {
+            (key: Bun.RedisClient.KeyLike, min: string | number, max: string | number): Promise<string[]>;
+            (key: Bun.RedisClient.KeyLike, min: string | number, max: string | number, withscores: "WITHSCORES"): Promise<[string, number][]>;
+            (key: Bun.RedisClient.KeyLike, min: string | number, max: string | number, limit: "LIMIT", offset: number, count: number): Promise<string[]>;
+            (key: Bun.RedisClient.KeyLike, min: string | number, max: string | number, withscores: "WITHSCORES", ...options: (string | number)[]): Promise<[string, number][]>;
+            (key: Bun.RedisClient.KeyLike, min: string | number, max: string | number, withscores: "WITHSCORES", limit: "LIMIT", offset: number, count: number, ...options: (string | number)[]): Promise<[string, number][]>;
+            (key: Bun.RedisClient.KeyLike, min: string | number, max: string | number, ...options: (string | number)[]): Promise<string[]>;
+        };
+    };
+    constructor(optionsOrURL: string | {
         name?: string;
         url: string;
     });
@@ -76,6 +91,8 @@ export declare class RedisConnection {
     getNetworkTokenValues(networkId: TNetworkId_S): Promise<TNetworkToken_S[]>;
     publishCustom(subChannel: 'kick-client-agent' | 'kick-client-authority', destinationProcessAddress: TProcessAddress, message: string): Promise<number>;
     subscribeToCustom(subChannel: 'kick-client-agent' | 'kick-client-authority', destinationProcessAddress: TProcessAddress, callback: (data: string) => void): void;
+    publishGlobal(networkId: TNetworkId_S, channel: 'agent-count-change' | `agent-throughput` | 'agent-created' | 'agent-deleted' | 'authority-count-change' | 'authority-created' | 'authority-deleted' | 'channel-created' | 'channel-usage' | 'channel-count' | 'channel-updated' | 'channel-deleted', message: string): Promise<number>;
+    subscribeGlobal(networkId: TNetworkId_S, channel: 'agent-count-change' | `agent-throughput` | 'agent-created' | 'agent-deleted' | 'authority-count-change' | 'authority-created' | 'authority-deleted' | 'channel-created' | 'channel-usage' | 'channel-count' | 'channel-updated' | 'channel-deleted', callback: (data: string) => void): Promise<void>;
     /**
      * Publishes a message directly to an address.
      */
@@ -97,14 +114,6 @@ export declare class RedisConnection {
      * Unsubscribes a callback from data packets on a specific network channel.
      */
     unsubscribeFromNetworkChannel(networkId: string, channelName: string, callback: (clientId: TClientId, data: string) => void): void;
-    /**
-     * Marks the given address as connected in Redis.
-     */
-    setConnected(address: string): Promise<void>;
-    /**
-     * Marks the given address as disconnected in Redis.
-     */
-    setDisconnected(_address: string): Promise<void>;
     /**
      * Disconnects the Redis cache and pub/sub.
      *