@nekzus/liop 1.2.0-alpha.10

package/dist/gateway/hybrid.d.ts

@@ -0,0 +1,23 @@
+import type { MeshNode } from "../mesh/index.js";
+import type { LiopServer } from "../server/index.js";
+import { LiopMcpRouter } from "./router.js";
+/**
+ * LIOP Hybrid Gateway
+ * High-level orchestration for connecting MCP (JSON-RPC) clients to the LIOP Mesh.
+ */
+export declare class LiopHybridGateway {
+    private liopServer;
+    private meshNode;
+    private netServer;
+    private h2Server;
+    private h1Server;
+    private router;
+    constructor(liopServer: LiopServer, meshNode?: MeshNode | null, rpcPort?: number);
+    private setupH2Routes;
+    private setupH1Routes;
+    private handleGrpcStream;
+    private handleMcpH2Stream;
+    listen(port: number, host?: string): Promise<number>;
+    stop(): Promise<void>;
+    getRouter(): LiopMcpRouter;
+}

package/dist/gateway/hybrid.js

@@ -0,0 +1,199 @@
+import * as http from "node:http";
+import * as http2 from "node:http2";
+import * as net from "node:net";
+import { log } from "../utils/logger.js";
+import { LiopMcpRouter } from "./router.js";
+/**
+ * LIOP Hybrid Gateway
+ * High-level orchestration for connecting MCP (JSON-RPC) clients to the LIOP Mesh.
+ */
+export class LiopHybridGateway {
+    liopServer;
+    meshNode;
+    netServer;
+    h2Server;
+    h1Server;
+    router;
+    constructor(liopServer, meshNode = null, rpcPort = 50051) {
+        this.liopServer = liopServer;
+        this.meshNode = meshNode;
+        // Initialize the Universal Router
+        this.router = new LiopMcpRouter(this.liopServer, this.meshNode, rpcPort);
+        // Internal HTTP/2 Server (for Native gRPC Proxying)
+        this.h2Server = http2.createServer();
+        this.setupH2Routes();
+        // Internal HTTP/1 Server (for Browser/MCP)
+        this.h1Server = http.createServer();
+        this.setupH1Routes();
+        // Primary Multiplexer (L4)
+        this.netServer = net.createServer((socket) => {
+            socket.once("data", (buffer) => {
+                const isHttp2 = buffer.toString().startsWith("PRI * HTTP/2.0");
+                log.info(`[LIOP-Gateway] Incoming L4 Connection. Protocol: ${isHttp2 ? "HTTP/2 (gRPC)" : "HTTP/1.1 (MCP)"}`);
+                if (isHttp2) {
+                    this.h2Server.emit("connection", socket);
+                }
+                else {
+                    this.h1Server.emit("connection", socket);
+                }
+                socket.unshift(buffer);
+            });
+            socket.on("error", (err) => log.error(`[LIOP-Gateway] NetServer Socket Error: ${err.message}`));
+        });
+        // Attach error listeners to sub-servers to catch silent failures
+        this.h1Server.on("error", (err) => log.error(`[LIOP-Gateway] H1 Server Error: ${err.message}`));
+        this.h2Server.on("error", (err) => log.error(`[LIOP-Gateway] H2 Server Error: ${err.message}`));
+        log.info("[LIOP-Gateway] Hybrid adapter initialized.");
+    }
+    setupH2Routes() {
+        this.h2Server.on("stream", (stream, headers) => {
+            const contentType = headers["content-type"];
+            const path = headers[":path"];
+            if (contentType === "application/grpc") {
+                this.handleGrpcStream(stream);
+            }
+            else if (path === "/mcp") {
+                this.handleMcpH2Stream(stream, headers);
+            }
+        });
+    }
+    setupH1Routes() {
+        this.h1Server.on("request", async (req, res) => {
+            const url = req.url || "";
+            const method = req.method;
+            if (method === "GET" &&
+                (url === "/" || url === "/mcp" || url === "/health")) {
+                if (url === "/health" &&
+                    req.headers.accept?.includes("application/json")) {
+                    const meshInfo = this.meshNode
+                        ? {
+                            peerId: this.meshNode.getPeerId()?.toString() || "",
+                            multiaddrs: this.meshNode
+                                .getMultiaddrs()
+                                .map((m) => m.toString()),
+                        }
+                        : null;
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        status: "healthy",
+                        node: this.liopServer.getServerInfo(),
+                        mesh: meshInfo,
+                        tools: this.liopServer.listTools().map((t) => t.name),
+                        timestamp: new Date().toISOString(),
+                    }));
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end(`
+                    <body style="background:#0f172a;color:#f8fafc;font-family:sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;margin:0">
+                        <div style="background:#1e293b;padding:40px;border-radius:16px;border:1px solid #38bdf8;text-align:center;box-shadow:0 20px 25px -5px rgba(0,0,0,0.1)">
+                            <h1 style="color:#38bdf8;margin-top:0">LIOP Protocol Transformer</h1>
+                            <p style="opacity:0.8;font-weight:600">L4/L7 Transcoding: JSON-RPC &harr; gRPC</p>
+                            <p style="opacity:0.6;font-size:14px">Active Protections: Kyber768 + AES-256-GCM + ZK-Proof Ready</p>
+                            <div style="background:#0f172a;padding:15px;border-radius:8px;margin-top:20px;border:1px dashed #334155">
+                                <code style="color:#10b981">Endpoint: http://localhost:3000/mcp</code>
+                            </div>
+                        </div>
+                    </body>
+                `);
+                return;
+            }
+            if (url === "/mcp" && method === "POST") {
+                let body = "";
+                req.on("data", (chunk) => (body += chunk.toString()));
+                req.on("end", async () => {
+                    try {
+                        const jsonRequest = JSON.parse(body);
+                        const response = await this.router.dispatch(jsonRequest);
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify(response));
+                    }
+                    catch (e) {
+                        log.info(`[LIOP-Gateway] Error processing JSON-RPC payload: ${e.message}`);
+                        res.writeHead(400);
+                        res.end(JSON.stringify({
+                            jsonrpc: "2.0",
+                            error: { code: -32700, message: "Parse error" },
+                        }));
+                    }
+                });
+            }
+            else {
+                res.writeHead(404);
+                res.end("Not Found");
+            }
+        });
+    }
+    handleGrpcStream(stream) {
+        stream.on("data", (chunk) => {
+            // biome-ignore lint/suspicious/noExplicitAny: Standard gRPC stream data is Buffer
+            const data = chunk;
+            if (data)
+                log.info(`[LIOP-Gateway] Native gRPC Proxy passing ${data.length} bytes`);
+        });
+        stream.respond({ ":status": 200, "content-type": "application/grpc" });
+        stream.end();
+    }
+    handleMcpH2Stream(stream, _headers) {
+        let body = "";
+        stream.on("data", (chunk) => (body += chunk.toString()));
+        stream.on("end", async () => {
+            try {
+                const response = await this.router.dispatch(JSON.parse(body));
+                if (response) {
+                    stream.respond({
+                        ":status": 200,
+                        "content-type": "application/json",
+                    });
+                    stream.end(JSON.stringify(response));
+                }
+                else
+                    stream.close();
+            }
+            catch (_e) {
+                stream.respond({ ":status": 400 });
+                stream.end();
+            }
+        });
+    }
+    async listen(port, host = "0.0.0.0") {
+        if (this.meshNode) {
+            await this.meshNode.start();
+            // Announce all local tools to the DHT
+            const tools = this.liopServer.listTools();
+            for (const tool of tools) {
+                await this.meshNode.announceCapability(tool.name);
+                log.info(`[LIOP-Gateway] 📡 Announced local tool to Mesh: ${tool.name}`);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            this.netServer.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    log.info(`[LIOP-Gateway] FATAL: Port ${port} is already in use by another process.`);
+                }
+                else {
+                    log.error(`[LIOP-Gateway] Binding Error: ${err.message}`);
+                }
+                reject(err);
+            });
+            this.netServer.listen(port, host, () => {
+                const addr = this.netServer.address();
+                const actualHost = typeof addr === "string" ? addr : addr?.address || host;
+                const assignedPort = typeof addr === "string" ? port : addr?.port || port;
+                log.info(`[LIOP-Gateway] ✅ Transformer Mesh Gateway READY and listening on ${actualHost}:${assignedPort}`);
+                resolve(assignedPort);
+            });
+        });
+    }
+    async stop() {
+        if (this.meshNode) {
+            await this.meshNode.stop();
+        }
+        this.netServer.close();
+        this.h2Server.close();
+        this.h1Server.close();
+    }
+    getRouter() {
+        return this.router;
+    }
+}

package/dist/gateway/router.d.ts

@@ -0,0 +1,69 @@
+import { LiopVerifier } from "../crypto/verifier.js";
+import type { MeshNode } from "../mesh/index.js";
+import type { LiopServer } from "../server/index.js";
+import type { McpRequest, McpResponse } from "../types.js";
+/**
+ * LIOP MCP Router
+ *
+ * Core logic for routing MCP requests to local or remote LIOP providers.
+ * Decoupled from transport (HTTP/Stdio).
+ *
+ * All tool discovery and port resolution is DYNAMIC via the
+ * /liop/manifest/1.0.0 protocol stream over Kademlia DHT.
+ */
+export declare class LiopMcpRouter {
+    private liopServer;
+    private meshNode;
+    private defaultRpcPort;
+    /** Cached manifests from remote peers. Key = PeerID */
+    private manifestCache;
+    /** Guards against concurrent discovery storms */
+    private currentDiscovery;
+    /** Verifier for Tier-0 integrity checks */
+    verifier: LiopVerifier;
+    /** Callback when new remote tools are discovered */
+    onToolsChanged?: () => void;
+    /** Circuit-breaker state for peers that repeatedly fail manifest queries. */
+    private manifestFailureState;
+    private static readonly MANIFEST_FAILURE_BASE_COOLDOWN_MS;
+    private static readonly MANIFEST_FAILURE_MAX_COOLDOWN_MS;
+    private static readonly MANIFEST_SKIP_LOG_THROTTLE_MS;
+    constructor(liopServer: LiopServer, meshNode?: MeshNode | null, defaultRpcPort?: number);
+    private shouldSkipManifestQuery;
+    private recordManifestQuerySuccess;
+    private recordManifestQueryFailure;
+    dispatch(request: McpRequest): Promise<McpResponse | null>;
+    /**
+     * MCP clients often send notifications/initialized then immediately tools/list.
+     * Start manifest discovery without blocking the notification handler.
+     */
+    private kickDiscoveryAfterInitialized;
+    /**
+     * Discovers and caches manifests from all remote LIOP providers in the mesh.
+     * Uses Kademlia DHT to find "liop:manifest" providers, then opens
+     * /liop/manifest/1.0.0 protocol streams to retrieve their full metadata.
+     */
+    refreshManifestCache(silent?: boolean): Promise<void>;
+    /**
+     * Returns the current manifest cache size for external telemetry.
+     * Used by the adaptive polling system to detect topology stabilization.
+     */
+    getCacheSize(): number;
+    /**
+     * Returns all remote tools discovered via the manifest protocol.
+     */
+    private getRemoteTools;
+    /**
+     * Returns all remote resources discovered via the manifest protocol.
+     */
+    private getRemoteResources;
+    /**
+     * Resolves the gRPC target (host:port) AND the peerId for a given tool name
+     * by searching the manifest cache. Supports exact names and suffixed names.
+     */
+    private resolveManifestTarget;
+    private transcodeMcpToLiop;
+    private routeToRemoteProvider;
+    private performTranscoding;
+    private encryptWithNonce;
+}