@persistica/flux-mesh 0.0.1

package/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "@persistica/flux-mesh",
+    "version": "0.0.1",
+    "description": "Persistica Flux Mesh",
+    "type": "module",
+    "keywords": [],
+    "publishConfig": {
+        "access": "public"
+    },
+    "types": "./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",
+    "dependencies": {}
+}

package/project.json

@@ -0,0 +1,80 @@
+{
+    "name": "persistica-flux-mesh",
+    "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+    "sourceRoot": "packages/flux/mesh/src",
+    "projectType": "library",
+    "tags": [
+        "type:npm-package",
+        "scope:any"
+    ],
+    "targets": {
+        "bun-serve": {
+            "executor": "nx:run-commands",
+            "options": {
+                "command": "bun --watch run ./packages/flux/mesh/src/main.ts"
+            }
+        },
+        "build": {
+            "executor": "nx:run-commands",
+            "options": {
+                "command": "bun run {projectRoot}/build.js",
+                "args": [
+                    "--projectRoot={projectRoot}"
+                ]
+            }
+        },
+        "serve": {
+            "executor": "@nx/js:node",
+            "defaultConfiguration": "development",
+            "dependsOn": [
+                "build"
+            ],
+            "options": {
+                "buildTarget": "persistica-flux-mesh:build",
+                "runBuildTargetDependencies": false
+            },
+            "configurations": {
+                "development": {
+                    "buildTarget": "persistica-flux-mesh:build:development"
+                },
+                "production": {
+                    "buildTarget": "persistica-flux-mesh:build:production"
+                }
+            }
+        },
+        "nx-release-publish": {
+            "options": {
+                "packageRoot": "dist/{projectRoot}"
+            }
+        },
+        "npm-publish": {
+            "executor": "nx:run-commands",
+            "options": {
+                "commands": [
+                    "npm login",
+                    "npm publish --access public"
+                ]
+            },
+            "dependsOn": [
+                "build"
+            ]
+        },
+        "bun-test": {
+            "executor": "nx:run-commands",
+            "options": {
+                "command": "bun test {projectRoot}/ --env-file=.env.e2e"
+            },
+            "dsa": "npm publish --access public --registry=https://registry.npmjs.org --scope=@persistica --workspace-root dist/{projectRoot}"
+        }
+    },
+    "release": {
+        "version": {
+            "currentVersionResolver": "git-tag",
+            "fallbackCurrentVersionResolver": "disk",
+            "preserveLocalDependencyProtocols": false,
+            "manifestRootsToUpdate": [
+                "dist/{projectRoot}"
+            ]
+        }
+    }
+}

package/src/_classes/web-rtc-client-interface.class.ts

@@ -0,0 +1,79 @@
+import type {
+    TProcessAddress,
+} from '@flux/shared/types';
+import { GlobalRPCClient2 } from '../routing/rpc/core/global-rpc-client.class';
+import {
+    type TRPCResponseCallbackFunction,
+    RPCClient,
+} from '@flux/shared/ws';
+
+export class WebRTCClient extends RPCClient<
+    'createOffer' | 'acceptOffer' | 'acceptAnswer' | 'answerAcceptedByInitiator'
+> {
+    constructor(
+        private readonly _originProcessAddress: TProcessAddress,
+        private readonly _sendToRPCServer: (
+            data: any, // ! Use 'unknown' or Bun.BufferSource (does not work)
+            compress?: boolean | undefined
+        ) => number,
+
+        // Handle the response from the RPC server
+        private readonly _handleResponseMessage: (
+            fn: TRPCResponseCallbackFunction,
+        ) => void
+    ) {
+        super(_sendToRPCServer, _handleResponseMessage);
+    }
+
+    public createOffer(): Promise<unknown> {
+        // TODO TYPE OFFER
+        return super.call(this._originProcessAddress, 'createOffer');
+    }
+
+    public acceptOfferAndCreateAnswer(
+        offer: unknown // TODO TYPE OFFER
+    ): Promise<unknown> {
+        // TODO TYOPE answer
+        return super.call(this._originProcessAddress, 'acceptOffer', offer);
+    }
+
+    public acceptAnswer(
+        answer: unknown // TODO TYPE answer
+    ): Promise<boolean> {
+        return super.call(this._originProcessAddress, 'acceptAnswer', answer);
+    }
+
+    public answerWasAccepted(answerAccepted: boolean): Promise<boolean> {
+        return super.call(
+            this._originProcessAddress,
+            'answerAcceptedByInitiator',
+            answerAccepted
+        );
+    }
+}
+
+export class GlobalWebRTCClient extends GlobalRPCClient2<
+    'createOffer' | 'acceptOffer' | 'acceptAnswer' | 'answerAcceptedByInitiator'
+> {
+    public createOffer(): Promise<unknown> {
+        // TODO TYPE OFFER
+        return super.call('createOffer');
+    }
+
+    public acceptOfferAndCreateAnswer(
+        offer: unknown // TODO TYPE OFFER
+    ): Promise<unknown> {
+        // TODO TYOPE answer
+        return super.call('acceptOffer', offer);
+    }
+
+    public acceptAnswer(
+        answer: unknown // TODO TYPE answer
+    ): Promise<boolean> {
+        return super.call('acceptAnswer', answer);
+    }
+
+    public answerWasAccepted(answerAccepted: boolean): Promise<boolean> {
+        return super.call('answerAcceptedByInitiator', answerAccepted);
+    }
+}

package/src/_routes/auth/network-authority.post.route.ts

@@ -0,0 +1,74 @@
+import type * as Bun from 'bun';
+import * as nodeURL from 'node:url';
+import { PicoLogger } from '@utils/pico-logger';
+import { generateToken } from '../../auth/auth';
+import {
+    type TNetworkId_S,
+    validateNetworkIdOrThrow,
+} from '@flux/shared/types';
+import {
+    type TFluxClientUID,
+    validateMachineUID,
+} from '@flux/shared/utils';
+
+/**
+ * This route is used to authorize a network authority.
+ * 
+ * @returns { Promise<Response> }
+ */
+export const authorizeNetworkAuthority = async (
+    request: Bun.BunRequest,
+): Promise<Response> => {
+    const urlWithParsedQuery: nodeURL.UrlWithParsedQuery = nodeURL.parse(request.url, true);
+
+    // Find the network authority to authenticate with
+    const networkIdString: string | string[] | undefined = urlWithParsedQuery.query['networkId'];
+
+    try {
+        validateNetworkIdOrThrow(networkIdString ?? '');
+    } catch (error) {
+        return new Response(
+            error instanceof Error ? error.message : 'Unknown error validating network ID',
+            {
+                status: 500,
+            },
+        );
+    }
+    const networkId: TNetworkId_S = networkIdString as TNetworkId_S;
+    const text = await request.text();
+
+    PicoLogger.log(`Received password:${text}${networkId}`, 'authorize');
+
+    console.error('TODOD: CHECK PASSWORD');
+
+    const cookies = request.cookies;
+
+    // Set a cookie with various options
+    cookies.set('user_id', '12345', {
+        maxAge: 60 * 60 * 24 * 7, // 1 week
+        httpOnly: true,
+        secure: true,
+        path: '/',
+    });
+
+    const machineUIDString: string | string[] | undefined = urlWithParsedQuery.query['machineUID'];
+    let machineUID: TFluxClientUID | undefined;
+    if (machineUIDString && validateMachineUID(machineUIDString)) {
+        machineUID = machineUIDString;
+    }
+
+    return new Response(
+        generateToken({
+            networkId,
+            isAuthority: true,
+            machineUID: machineUID,
+        }),
+        {
+            headers: {
+                'Content-Type': 'text/plain',
+                'Access-Control-Allow-Origin': '*',
+                'Set-Cookie': 'sessionId=abc123; HttpOnly; Max-Age=3600',
+            },
+        }
+    );
+};

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

@@ -0,0 +1,169 @@
+import type { BunRequest } from 'bun';
+import * as nodeURL from 'node:url';
+import {
+    type TAddress,
+    type TNetworkId_S,
+    GlobalRPCTimeoutError,
+    UnknownClientError,
+    validateAgentUIDOrThrow,
+    validateNetworkIdOrThrow,
+} from '@flux/shared/types';
+import { generateToken } from '../../auth/auth';
+import type { GlobalRPCClient } from '../../routing/rpc/core/global-rpc-client.class';
+import type { NetworkAuthorityManager } from '../../register/register-network-authority.class';
+import { retry } from '@flux/shared/utils';
+import {
+    type TFluxClientUID,
+    validateMachineUID,
+} from '@flux/shared/utils';
+
+/**
+ * 
+ * @param { BunRequest }                    request
+ * @param { NetworkAuthorityManager }       networkAuthorityManager
+ * @param { GlobalRPCClient<'authorize'> }  globalRPCClient
+ * 
+ * @returns { void }
+ */
+export const authorizeNetworkAgent = async (
+    request: BunRequest,
+    networkAuthorityManager: NetworkAuthorityManager,
+    globalRPCClient: GlobalRPCClient<'authorize'>,
+) => {
+    const urlWithParsedQuery: nodeURL.UrlWithParsedQuery = nodeURL.parse(request.url, true);
+
+    // Find the network authority to authenticate with
+    const networkIdString: string | string[] | undefined = urlWithParsedQuery.query['networkId'];
+
+    try {
+        validateNetworkIdOrThrow(networkIdString ?? '');
+    } catch (error) {
+        return new Response(
+            error instanceof Error ? error.message : 'Unknown error validating network ID',
+            {
+                status: 500,
+            },
+        );
+    }
+    const networkId: TNetworkId_S = networkIdString as TNetworkId_S;
+
+    if (!networkId) {
+        return new Response('Missing networkId', {
+            status: 500,
+            headers: {
+                //   'Access-Control-Allow-Origin': '*',
+            },
+        });
+    }
+
+    const text = await request.text();
+
+    const contentType = request.headers
+        .get('x-flux-content-type')
+        ?.toLowerCase();
+
+    try {
+        let networkAuthorityAddress: TAddress;
+
+        const authorizedJWT: string = await retry<string>(
+            async () => {
+                networkAuthorityAddress = await networkAuthorityManager
+                    .resolveNetworkAuthorityAddressOrThrow(
+                        networkId,
+                    );
+
+                return globalRPCClient.call(
+                    networkAuthorityAddress,
+                    'authorize',
+                    `${contentType === 'application/json' ? 'json' : 'text'}:${text}`
+                );
+            },
+            (error: unknown) => {
+                if (
+                    (error instanceof UnknownClientError) ||
+                    (error instanceof GlobalRPCTimeoutError)
+                ) {
+                    networkAuthorityManager.removeUnresponsiveClient(
+                        networkId,
+                        networkAuthorityAddress,
+                    );
+
+                    return true;
+                }
+
+                return false;
+            },
+            {
+                retries: 10,
+                delayMs: 50,
+                onRetry: (
+                    attempt: number,
+                    retries: number,
+                ) => {
+                    console.log(`[authorizeNetworkAgent] Retrying... (attempt: ${attempt} of ${retries})`);
+                },
+            },
+        );
+
+        // const authorizedJWT: string = await globalRPCClient.call(
+        //     networkAuthorityAddress,
+        //     'authorize',
+        //     `${contentType === 'application/json' ? 'json' : 'text'}:${text}`
+        // );
+
+        if (authorizedJWT) {
+            const requestedAgentUidString: string | string[] | undefined = urlWithParsedQuery.query['requestedAgentUid'];
+
+            if (requestedAgentUidString) {
+                try {
+                    validateAgentUIDOrThrow(requestedAgentUidString);
+                } catch (error) {
+                    return new Response(
+                        error instanceof Error ? error.message : 'The requested agent ID is not valid',
+                        {
+                            status: 500,
+                        },
+                    );
+                }
+            }
+
+            const cookies = request.cookies;
+
+            // Set a cookie with various options
+            cookies.set('claim', authorizedJWT, {
+                maxAge: 60 * 60 * 24 * 7, // 1 week
+                httpOnly: true,
+                secure: true,
+                path: '/',
+            });
+
+            const machineUIDString: string | string[] | undefined = urlWithParsedQuery.query['machineUID'];
+            let machineUID: TFluxClientUID | undefined;
+            if (machineUIDString && validateMachineUID(machineUIDString)) {
+                machineUID = machineUIDString;
+            }
+
+            return new Response(
+                generateToken({
+                    networkId,
+                    claim: authorizedJWT,
+                    agentUID: requestedAgentUidString,
+                    machineUID: machineUID,
+                }),
+                {
+                    headers: {
+                        'Content-Type': 'text/plain',
+                        'Access-Control-Allow-Origin': '*',
+                        //   'Set-Cookie': `sessionId=abc123; HttpOnly; Max-Age=3600; signed=true; Path=/;`,
+                    },
+                }
+            );
+        }
+    } catch (error) {
+        console.error('Error authorizing:', error);
+    }
+
+    return new Response('Unauthorized', {
+        status: 500,
+    });
+};

package/src/_routes/options.route.ts

@@ -0,0 +1,9 @@
+export const OPTIONS_RESPONSE = () =>
+    new Response(null, {
+        status: 204,
+        headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, x-flux-content-type, Set-Cookie',
+        },
+    });

package/src/auth/auth.ts

@@ -0,0 +1,29 @@
+import jwt from 'jsonwebtoken';
+
+const secret = 'your-very-secure-secret'; // keep this secret safe!
+
+export const generateToken = (
+    payload: object,
+    expiresIn = 60_000 //! TODOD CHANGE TO LOW VALUE AGAINGA.. FOR DEVE.. Live for 60 seconds
+): string => {
+    return jwt.sign(payload, secret, { expiresIn });
+};
+
+export const verifyTokenOrThrow = (
+    token: unknown,
+    // callback?: VerifyCallback<JwtPayload | string>,
+): object => {
+    if (typeof token !== 'string') {
+        throw new Error('Token must be a string');
+    }
+
+    try {
+        const decoded = jwt.verify(token, secret);
+
+        return decoded as any;
+    } catch (err) {
+        console.error('Invalid or expired token', (<any>err).message);
+
+        throw new Error('Invalid or expired token');
+    }
+};

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

@@ -0,0 +1,209 @@
+import {
+    type TAddress,
+    type TChannelName,
+    type TNetworkId_S,
+    AUTHORITY_ON_CREATE_CHANNEL,
+    AUTHORITY_ON_EMPTY_CHANNEL,
+} from '@flux/shared/types';
+import { NetworkChannelHash } from '@flux/mesh/store/redis/network-channel';
+import {
+    type RedisConnection,
+    getMeshRedisConnection,
+} from '../../routing/redis/redis-connection.class';
+import type { GlobalChannelPubsub } from '../../routing/global-channel/global-channel-pubsub.class';
+
+// ! TODO Hardcoded for now, take from network config in the future
+const MAX_CHANNEL_MEMBERS = 25;
+
+interface IUsageCache {
+    networkId: TNetworkId_S;
+    usage: number;
+};
+export class NetworkChannelManager {
+    private readonly channelUsageCount: Map<TChannelName, IUsageCache> = new Map();
+    private readonly redisConnection: RedisConnection = getMeshRedisConnection();
+    private readonly networkChannelHash: NetworkChannelHash = new NetworkChannelHash(
+        this.redisConnection,
+    );
+
+    constructor(
+        private readonly _globalChannelPubsub: GlobalChannelPubsub,
+    ) {
+        setInterval(() => {
+            for (const [channelName, usage] of this.channelUsageCount) {
+
+                if (usage.usage > 0) {
+                    this.networkChannelHash
+                        .incrementUsage(
+                            usage.networkId,
+                            channelName,
+                            usage.usage,
+                        );
+                }
+
+                this.channelUsageCount.delete(channelName);
+            }
+        }, 5_000);
+    }
+
+    /**
+     * Checks if a channel can have more members.
+     *  
+     * ! TODO Don't query the database repeatedly, implement local synced cache.
+     * 
+     * @param { TNetworkId_S } networkId
+     * @param { TChannelName } channelName
+     *
+     * @returns { Promise<boolean> }
+     */
+    public async canHaveMembers(
+        networkId: TNetworkId_S,
+        channelName: TChannelName,
+    ): Promise<boolean> {
+        const count: number = await this.networkChannelHash.readNetworkMemberCount(
+            networkId,
+            channelName,
+        );
+
+        return Promise.resolve(count < MAX_CHANNEL_MEMBERS);
+    }
+
+    /**
+     * Joins a network channel.
+     * 
+     * @param { TNetworkId_S }  networkId 
+     * @param { TChannelName }  channelName 
+     * @param { TAddress }      clientAddress
+     * 
+     * @returns { void } 
+     */
+    public joinNetworkChannel(
+        networkId: TNetworkId_S,
+        channelName: TChannelName,
+        clientAddress: TAddress,
+    ): void {
+        this.createNetworkChannelIfNotExist(
+            networkId,
+            channelName,
+        );
+
+        this.networkChannelHash.joinNetworkChannel(
+            networkId,
+            channelName,
+            clientAddress,
+        );
+    }
+
+    /**
+     * Leaves a network channel.
+     * 
+     * @param { TNetworkId_S }  networkId 
+     * @param { TChannelName }  channelName 
+     * @param { TAddress }      clientAddress
+     * 
+     * @returns { Promise<void> } 
+     */
+    public async leaveNetworkChannel(
+        networkId: TNetworkId_S,
+        channelName: TChannelName,
+        clientAddress: TAddress,
+    ): Promise<void> {
+        const membersLeft: number = await this.networkChannelHash
+            .leaveNetworkChannel(
+                networkId,
+                channelName,
+                clientAddress,
+            );
+
+        if (membersLeft === 0) {
+            this._globalChannelPubsub
+                .publish(
+                    `~/networks/${networkId}/channel-empty`,
+                    `${AUTHORITY_ON_EMPTY_CHANNEL}:${channelName}`,
+                );
+        }
+    }
+
+    /**
+     * Leaves all network channels.
+     * 
+     * @param { TNetworkId_S }          networkId
+     * @param { TAddress }              clientAddress
+     * @param { Set<TChannelName> }     channelNames
+     * 
+     * @returns { void } 
+     */
+    public leaveAllNetworkChannels(
+        networkId: TNetworkId_S,
+        clientAddress: TAddress,
+        channelNames: Set<TChannelName>,
+    ): void {
+        this.networkChannelHash.leaveAllNetworkChannels(
+            networkId,
+            clientAddress,
+            channelNames,
+        );
+    }
+
+    /**
+     * Creates a network channel if it does not exist.
+     * 
+     * @param { TNetworkId_S }  networkId
+     * @param { TChannelName }  channelName
+     * 
+     * @returns { void } 
+     */
+    private async createNetworkChannelIfNotExist(
+        networkId: TNetworkId_S,
+        channelName: TChannelName,
+    ): Promise<void> {
+        const wasCreated: boolean = await this.networkChannelHash
+            .createNetworkChannelIfNotExist(
+                networkId,
+                channelName,
+            );
+
+        if (wasCreated) {
+            this._globalChannelPubsub
+                .publish(
+                    `~/networks/${networkId}/channel-created`,
+                    `${AUTHORITY_ON_CREATE_CHANNEL}:${channelName}`,
+                );
+        }
+    }
+
+    // ****************************************************************************
+    // *** Update
+    // ****************************************************************************
+
+    /**
+     * Increases the usage count of a channel.
+     * 
+     * @param { TNetworkId_S } networkId
+     * @param { TChannelName } channelName
+     * @param { number } usage
+     * 
+     * @returns { void }
+     */
+    public increaseUsageCount(
+        networkId: TNetworkId_S,
+        channelName: TChannelName,
+        usage: number,
+    ): void {
+        const channelUsageCache: {
+            networkId: TNetworkId_S;
+            usage: number;
+        } | undefined = this.channelUsageCount.get(channelName);
+
+        this.channelUsageCount.set(
+            channelName,
+            channelUsageCache ? {
+                ...channelUsageCache,
+                usage: channelUsageCache.usage + usage,
+            } : {
+                networkId,
+                usage: usage,
+            },
+        );
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export {
+    FluxMeshServer,
+} from './main';