aegis-fluxion

Main end-user package for the aegis-fluxion secure messaging ecosystem.

Version: 0.7.6

Re-exported modules

aegis-fluxion re-exports all public APIs from:

• @aegis-fluxion/core
• @aegis-fluxion/browser-client
• @aegis-fluxion/mcp-adapter
• @aegis-fluxion/redis-adapter

This means you can build encrypted transport, MCP bridges, and Redis-based horizontal scaling without multiple package-level imports.

What's new in 0.7.6

• Observability & Telemetry support landed in @aegis-fluxion/core@^0.10.0.
• SecureServer now exposes:
  • getMetrics() JSON snapshots
  • getMetricsPrometheus() Prometheus-friendly output
• Telemetry includes active connection gauge, handshake counters, encrypted message traffic, and blocked DDoS/rate-limit counters.

Install

npm install aegis-fluxion ws redis

Quick start

import { SecureClient, SecureServer } from "aegis-fluxion";

const server = new SecureServer({ host: "127.0.0.1", port: 8080 });

server.on("tasks:create", async (payload) => {
  return {
    ok: true,
    payload
  };
});

const client = new SecureClient("ws://127.0.0.1:8080");

client.on("ready", async () => {
  const response = await client.emit("tasks:create", { id: "t-1" }, { timeoutMs: 1200 });
  console.log(response);
});

Observability quick example

import { createServer } from "node:http";
import { SecureServer } from "aegis-fluxion";

const secureServer = new SecureServer({ host: "127.0.0.1", port: 8080 });

createServer((request, response) => {
  if (request.url === "/metrics") {
    response.setHeader("Content-Type", "text/plain; version=0.0.4; charset=utf-8");
    response.end(secureServer.getMetricsPrometheus());
    return;
  }

  if (request.url === "/metrics.json") {
    response.setHeader("Content-Type", "application/json; charset=utf-8");
    response.end(JSON.stringify(secureServer.getMetrics(), null, 2));
    return;
  }

  response.statusCode = 404;
  response.end("Not Found");
}).listen(9100, "127.0.0.1");

Frontend React quick example

import { useEffect, useMemo, useState } from "react";
import { BrowserSecureClient } from "aegis-fluxion";

export function SecureTimeline() {
  const [status, setStatus] = useState("connecting");

  const client = useMemo(() => {
    return new BrowserSecureClient("wss://api.example.com/socket", {
      autoConnect: false,
      reconnect: true
    });
  }, []);

  useEffect(() => {
    const handleReady = () => setStatus("ready");
    const handleDisconnect = () => setStatus("disconnected");

    client.on("ready", handleReady);
    client.on("disconnect", handleDisconnect);
    client.connect();

    return () => {
      client.off("ready", handleReady);
      client.off("disconnect", handleDisconnect);
      client.disconnect();
    };
  }, [client]);

  return <p>Secure browser socket status: {status}</p>;
}

Session resumption quick example

import { SecureClient, SecureServer } from "aegis-fluxion";

const server = new SecureServer({
  host: "127.0.0.1",
  port: 8080,
  sessionResumption: {
    enabled: true,
    ticketTtlMs: 60_000,
    maxCachedTickets: 2_048
  }
});

const client = new SecureClient("ws://127.0.0.1:8080", {
  reconnect: true,
  sessionResumption: {
    enabled: true,
    maxAcceptedTicketTtlMs: 60_000
  }
});

client.on("ready", () => {
  console.log("Secure channel is ready (resumed or full handshake).");
});

Chunked streaming quick example

import { SecureClient, SecureServer } from "aegis-fluxion";

const server = new SecureServer({ host: "127.0.0.1", port: 8080 });
const client = new SecureClient("ws://127.0.0.1:8080");

server.onStream("blob:upload", async (stream, info) => {
  const chunks: Buffer[] = [];

  for await (const chunk of stream) {
    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
  }

  const fullBuffer = Buffer.concat(chunks);

  console.log("Received stream", {
    streamId: info.streamId,
    announcedTotalBytes: info.totalBytes,
    receivedBytes: fullBuffer.length
  });
});

client.on("ready", async () => {
  const payload = Buffer.from("large payload");

  const result = await client.emitStream("blob:upload", payload, {
    chunkSizeBytes: 64 * 1024,
    totalBytes: payload.length,
    metadata: { source: "client" }
  });

  console.log(result);
});

Horizontal scaling example (Redis adapter)

import {
  RedisSecureServerAdapter,
  SecureServer
} from "aegis-fluxion";

const redisUrl = "redis://127.0.0.1:6379";
const channel = "aegis-fluxion:cluster:prod";

const adapterA = new RedisSecureServerAdapter({ redisUrl, channel });
const adapterB = new RedisSecureServerAdapter({ redisUrl, channel });

const serverA = new SecureServer({
  host: "127.0.0.1",
  port: 8081,
  adapter: adapterA
});

const serverB = new SecureServer({
  host: "127.0.0.1",
  port: 8082,
  adapter: adapterB
});

serverA.on("connection", (client) => client.join("alerts"));
serverB.on("connection", (client) => client.join("alerts"));

serverA.to("alerts").emit("alerts:new", {
  level: "info",
  source: "server-a"
});

MCP transport example

import {
  SecureClient,
  SecureMCPTransport,
  SecureServer,
  type SecureMCPMessage
} from "aegis-fluxion";

const secureServer = new SecureServer({ host: "127.0.0.1", port: 9092 });

secureServer.on("connection", async (client) => {
  const serverTransport = new SecureMCPTransport({
    mode: "server",
    server: secureServer,
    clientId: client.id
  });

  serverTransport.onmessage = async (message: SecureMCPMessage) => {
    console.log("Server MCP message", message);
  };

  await serverTransport.start();
});

const secureClient = new SecureClient("ws://127.0.0.1:9092");

const clientTransport = new SecureMCPTransport({
  mode: "client",
  client: secureClient
});

await clientTransport.start();
await clientTransport.send({
  jsonrpc: "2.0",
  id: 1,
  method: "tools/list",
  params: {}
});

Related documentation

• Core: ../core/README.md
• Browser client: ../browser-client/README.md
• Redis adapter: ../redis-adapter/README.md
• MCP adapter: ../mcp-adapter/README.md
• Changelog: ../../CHANGELOG.md

License

MIT