@nekzus/liop 2.4.0-alpha.25 → 2.4.0-alpha.26

package/dist/chunk-WXOWJXY6.js

@@ -1,564 +0,0 @@
-import { MCP_LEGACY_SUPPORT_ENABLED, isLegacyRequest, MCP_PROTOCOL_VERSION_LEGACY, MCP_PROTOCOL_VERSION } from './chunk-KR5UZUEY.js';
-import { log } from './chunk-K3DGJLUY.js';
-import { randomUUID } from 'crypto';
-import { serve } from '@hono/node-server';
-import { Hono } from 'hono';
-import { cors } from 'hono/cors';
-
-var DEFAULT_MAX_SESSIONS_PER_IP = 10;
-var DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
-var EVICTION_INTERVAL_MS = 60 * 1e3;
-var LiopStreamBridge = class {
-  constructor(internalServer, options = {}) {
-    this.options = options;
-    this.app = new Hono();
-    this.bridgeLogic = new LiopMcpBridge(internalServer);
-    this.activeSessions = /* @__PURE__ */ new Map();
-    this.maxSessionsPerIp = options.maxSessionsPerIp ?? DEFAULT_MAX_SESSIONS_PER_IP;
-    this.sessionTimeoutMs = options.sessionTimeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;
-    this.setupRoutes();
-  }
-  options;
-  app;
-  httpServer = null;
-  bridgeLogic;
-  activeSessions;
-  evictionTimer = null;
-  maxSessionsPerIp;
-  sessionTimeoutMs;
-  /**
-   * Creates a new per-session transport instance and wires it to the LIOPMcpBridge logic.
-   */
-  async createSessionTransport(clientIp) {
-    const { WebStandardStreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js');
-    const transport = new WebStandardStreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID(),
-      onsessioninitialized: (sessionId) => {
-        this.activeSessions.set(sessionId, {
-          transport,
-          lastActivity: Date.now(),
-          clientIp
-        });
-        log.info(
-          `[LIOP-StreamBridge] Session opened: ${sessionId} (IP: ${clientIp})`
-        );
-      }
-    });
-    transport.onmessage = async (message) => {
-      if (transport.sessionId) {
-        const entry = this.activeSessions.get(transport.sessionId);
-        if (entry) entry.lastActivity = Date.now();
-      }
-      try {
-        const result = await this.bridgeLogic.handleJsonRpcRequest(
-          message
-        );
-        if (result !== void 0) {
-          await transport.send(result);
-        }
-      } catch (err) {
-        log.info("[LIOP-StreamBridge] JSON-RPC error:", err.message);
-      }
-    };
-    transport.onclose = () => {
-      if (transport.sessionId) {
-        this.activeSessions.delete(transport.sessionId);
-        log.info(`[LIOP-StreamBridge] Session closed: ${transport.sessionId}`);
-      }
-    };
-    return transport;
-  }
-  /**
-   * Returns the number of active sessions for a given IP.
-   */
-  countSessionsByIp(ip) {
-    let count = 0;
-    for (const entry of this.activeSessions.values()) {
-      if (entry.clientIp === ip) count++;
-    }
-    return count;
-  }
-  /**
-   * Extracts client IP from the request (supports X-Forwarded-For for reverse proxies).
-   */
-  getClientIp(c) {
-    return c.req.header("x-forwarded-for")?.split(",")[0]?.trim() || c.req.header("x-real-ip") || "unknown";
-  }
-  /**
-   * Evicts sessions that have been idle longer than the configured timeout.
-   */
-  evictIdleSessions() {
-    const now = Date.now();
-    for (const [sessionId, entry] of this.activeSessions) {
-      if (now - entry.lastActivity > this.sessionTimeoutMs) {
-        log.info(`[LIOP-StreamBridge] Evicting idle session: ${sessionId}`);
-        entry.transport.close().catch(() => {
-        });
-        this.activeSessions.delete(sessionId);
-      }
-    }
-  }
-  setupRoutes() {
-    this.app.use("*", cors());
-    if (!process.env.ZERO_TRUST_TOKEN) {
-      process.env.ZERO_TRUST_TOKEN = randomUUID();
-      log.info("=".repeat(60));
-      log.info("\u26A0\uFE0F STRICT ZERO-TRUST MODE ENABLED \u26A0\uFE0F");
-      log.info("No ZERO_TRUST_TOKEN found in environment.");
-      log.info("A secure ephemeral token has been generated for this session:");
-      log.info(`Token: ${process.env.ZERO_TRUST_TOKEN}`);
-      log.info("=".repeat(60));
-    }
-    this.app.use("/mcp", async (c, next) => {
-      const auth = c.req.header("Authorization");
-      if (!auth?.startsWith("Bearer ")) {
-        return c.json(
-          { error: "Unauthorized: LIOP Zero-Trust Policy Enforced" },
-          401
-        );
-      }
-      const token = auth.slice(7);
-      const expectedToken = process.env.ZERO_TRUST_TOKEN;
-      if (expectedToken && token === expectedToken) {
-        await next();
-        return;
-      }
-      const jwtValidator = this.bridgeLogic.getServer()?.jwtValidator;
-      if (jwtValidator) {
-        try {
-          await jwtValidator.validate(token);
-          await next();
-          return;
-        } catch (e) {
-          log.info(
-            `[LIOP-StreamBridge] JWT Validation failed: ${e.message}`
-          );
-          return c.json(
-            {
-              error: `Unauthorized: JWT Validation failed - ${e.message}`
-            },
-            401
-          );
-        }
-      }
-      log.info(
-        "[LIOP-StreamBridge] ALERT: Access denied - Invalid Zero-Trust token."
-      );
-      return c.json(
-        { error: "Unauthorized: LIOP Zero-Trust Policy Enforced" },
-        401
-      );
-    });
-    this.app.all("/mcp", async (c) => {
-      const sessionId = c.req.header("mcp-session-id");
-      if (sessionId) {
-        if (!MCP_LEGACY_SUPPORT_ENABLED) {
-          return c.json(
-            {
-              error: "Session-based routing is retired. Use stateless MCP 2026-07-28 requests."
-            },
-            404
-          );
-        }
-        const existing = this.activeSessions.get(sessionId);
-        if (!existing) {
-          return c.json({ error: "Session not found" }, 404);
-        }
-        existing.lastActivity = Date.now();
-        const response = await existing.transport.handleRequest(c.req.raw);
-        if (c.req.method === "DELETE") {
-          this.activeSessions.delete(sessionId);
-          log.info(`[LIOP-StreamBridge] Session closed (DELETE): ${sessionId}`);
-        }
-        return response;
-      }
-      const contentType = c.req.header("content-type") || "";
-      if (c.req.method === "POST" && contentType.includes("application/json")) {
-        try {
-          const body = await c.req.json();
-          if (body.method === "server/discover" || body.params?._meta || !MCP_LEGACY_SUPPORT_ENABLED) {
-            const result = await this.bridgeLogic.handleJsonRpcRequest(body);
-            if (result !== void 0) {
-              return c.json(result);
-            }
-            return c.body(null, 204);
-          }
-        } catch {
-        }
-      }
-      if (!MCP_LEGACY_SUPPORT_ENABLED) {
-        return c.json(
-          {
-            error: "Stateless MCP 2026-07-28 is active. Direct JSON-RPC POST required."
-          },
-          400
-        );
-      }
-      const clientIp = this.getClientIp(c);
-      const currentSessions = this.countSessionsByIp(clientIp);
-      if (currentSessions >= this.maxSessionsPerIp) {
-        log.info(
-          `[LIOP-StreamBridge] Rate limit hit for IP: ${clientIp} (${currentSessions} sessions)`
-        );
-        return c.json({ error: "Too Many Sessions: Rate limit exceeded" }, 429);
-      }
-      const transport = await this.createSessionTransport(clientIp);
-      return await transport.handleRequest(c.req.raw);
-    });
-  }
-  /**
-   * Starts the LiopStreamBridge HTTP server and session eviction timer.
-   */
-  async start(port) {
-    const listenPort = port ?? this.options.port ?? 3e3;
-    this.evictionTimer = setInterval(
-      () => this.evictIdleSessions(),
-      EVICTION_INTERVAL_MS
-    );
-    return new Promise((resolve) => {
-      this.httpServer = serve(
-        {
-          fetch: this.app.fetch,
-          port: listenPort
-        },
-        (info) => {
-          log.info(
-            `[LIOP-StreamBridge] Streamable HTTP Gateway on http://localhost:${info.port}/mcp`
-          );
-          resolve();
-        }
-      );
-    });
-  }
-  /**
-   * Graceful shutdown — closes all active sessions, stops timers, and releases port.
-   */
-  async stop() {
-    if (this.evictionTimer) {
-      clearInterval(this.evictionTimer);
-      this.evictionTimer = null;
-    }
-    for (const [id, entry] of this.activeSessions) {
-      await entry.transport.close();
-      this.activeSessions.delete(id);
-    }
-    if (this.httpServer) {
-      this.httpServer.close();
-      log.info("[LIOP-StreamBridge] HTTP ports released.");
-    }
-  }
-};
-
-// src/bridge/index.ts
-var LiopMcpBridge = class {
-  constructor(source, options = {}) {
-    this.options = options;
-    if (source?.constructor?.name === "LiopServer") {
-      this.liopServer = source;
-      log.info("[LIOP-Bridge] Mode: EXPOSE (LIOP -> MCP Stdio)");
-    } else if (source?.constructor?.name === "McpServer") {
-      this.legacyMcpServer = source;
-      log.info("[LIOP-Bridge] Mode: WRAP (Legacy MCP -> LIOP Mesh)");
-    } else {
-      this.legacyMcpServer = source;
-      log.info("[LIOP-Bridge] Mode: WRAP (Inferred Legacy MCP -> LIOP Mesh)");
-    }
-  }
-  options;
-  liopServer = null;
-  legacyMcpServer = null;
-  /**
-   * Handles an incoming standard MCP JSON-RPC 2.0 payload.
-   * Pipes it to the underlying server (LIOP or Legacy MCP).
-   */
-  async handleJsonRpcRequest(payload) {
-    const id = payload.id;
-    const method = payload.method;
-    const params = payload.params;
-    if (payload.jsonrpc !== "2.0") {
-      return this.errorResponse(id, -32600, "Invalid Request");
-    }
-    if (this.liopServer) {
-      return this.handleLiopToMcp(id, method, params);
-    }
-    if (this.legacyMcpServer && this.liopServer) {
-      return this.handleLiopToMcp(id, method, params);
-    }
-    return this.errorResponse(id, -32601, "Bridge source not configured");
-  }
-  async handleLiopToMcp(id, method, params) {
-    if (!this.liopServer) return null;
-    const isLegacy = MCP_LEGACY_SUPPORT_ENABLED && isLegacyRequest({ method, params, id });
-    if (method === "initialize") {
-      if (!MCP_LEGACY_SUPPORT_ENABLED) {
-        return this.errorResponse(id, -32601, "Method retired: initialize");
-      }
-      return this.successResponse(id, {
-        protocolVersion: MCP_PROTOCOL_VERSION_LEGACY,
-        capabilities: {
-          prompts: { listChanged: true },
-          resources: { listChanged: true },
-          tools: { listChanged: true }
-        },
-        serverInfo: this.liopServer.getServerInfo()
-      });
-    }
-    if (method === "server/discover") {
-      return this.successResponse(id, {
-        resultType: "complete",
-        supportedVersions: MCP_LEGACY_SUPPORT_ENABLED ? [MCP_PROTOCOL_VERSION, MCP_PROTOCOL_VERSION_LEGACY] : [MCP_PROTOCOL_VERSION],
-        capabilities: {
-          prompts: { listChanged: true },
-          resources: { listChanged: true },
-          tools: { listChanged: true }
-        },
-        serverInfo: this.liopServer.getServerInfo()
-      });
-    }
-    if (method === "notifications/initialized") return void 0;
-    if (method === "ping") return this.successResponse(id, {});
-    if (method === "tools/list") {
-      const tools = this.liopServer.listTools().sort((a, b) => a.name.localeCompare(b.name));
-      return this.successResponse(
-        id,
-        isLegacy ? { tools } : {
-          resultType: "complete",
-          ttlMs: 3e5,
-          cacheScope: "public",
-          tools
-        }
-      );
-    }
-    if (method === "resources/list") {
-      const resources = this.liopServer.listResources().sort((a, b) => a.uri.localeCompare(b.uri));
-      return this.successResponse(
-        id,
-        isLegacy ? { resources } : {
-          resultType: "complete",
-          ttlMs: 3e5,
-          cacheScope: "public",
-          resources
-        }
-      );
-    }
-    if (method === "prompts/list") {
-      const prompts = this.liopServer.listPrompts().sort((a, b) => a.name.localeCompare(b.name));
-      return this.successResponse(
-        id,
-        isLegacy ? { prompts } : {
-          resultType: "complete",
-          ttlMs: 3e5,
-          cacheScope: "public",
-          prompts
-        }
-      );
-    }
-    if (method === "prompts/get") {
-      if (!params?.name) {
-        return this.errorResponse(id, -32602, "Missing prompt name");
-      }
-      try {
-        const result = await this.liopServer.getPrompt({
-          name: params.name,
-          arguments: params.arguments
-        });
-        return this.successResponse(
-          id,
-          isLegacy || typeof result !== "object" || result === null ? result : { resultType: "complete", ...result }
-        );
-      } catch (err) {
-        return this.errorResponse(id, -32e3, err.message);
-      }
-    }
-    if (method === "resources/read") {
-      if (!params?.uri) {
-        return this.errorResponse(id, -32602, "Missing resource URI");
-      }
-      try {
-        const result = await this.liopServer.readResource(params.uri);
-        return this.successResponse(
-          id,
-          isLegacy ? result : typeof result === "object" && result !== null ? {
-            resultType: "complete",
-            ttlMs: 6e4,
-            cacheScope: "private",
-            ...result
-          } : {
-            resultType: "complete",
-            ttlMs: 6e4,
-            cacheScope: "private",
-            contents: result
-          }
-        );
-      } catch (err) {
-        return this.errorResponse(id, -32e3, err.message);
-      }
-    }
-    if (method === "tools/call") {
-      if (!params?.name) {
-        return this.errorResponse(id, -32602, "Missing tool name");
-      }
-      const request = {
-        name: params.name,
-        arguments: params.arguments || {}
-      };
-      try {
-        const result = await this.liopServer.callTool(request);
-        const isVerified = result.isError ? true : await this.verifyZkReceipt(request, result);
-        if (!isVerified) {
-          return this.successResponse(id, {
-            content: [
-              {
-                type: "text",
-                text: "ALERT [LIOP ZERO-TRUST SHIELD] ZK Verification Failed. The mathematical ImageID does not match the original payload."
-              }
-            ],
-            isError: true
-          });
-        }
-        return this.successResponse(
-          id,
-          isLegacy ? result : {
-            resultType: "complete",
-            ...result
-          }
-        );
-      } catch (err) {
-        return this.errorResponse(id, -32e3, err.message);
-      }
-    }
-    return this.errorResponse(id, -32601, "Method not found");
-  }
-  successResponse(id, result) {
-    return { jsonrpc: "2.0", id, result };
-  }
-  errorResponse(id, code, message) {
-    return { jsonrpc: "2.0", id, error: { code, message } };
-  }
-  async verifyZkReceipt(request, result) {
-    if (!request.arguments?.payload || typeof request.arguments.payload !== "string") {
-      return true;
-    }
-    try {
-      const payload = request.arguments.payload;
-      const contentText = result.content[0]?.text;
-      if (contentText && typeof contentText === "string") {
-        try {
-          const data = JSON.parse(contentText);
-          if (data.image_id || data.zk_receipt) {
-            const { LiopVerifier } = await import('./verifier-55HW6AFN.js');
-            const verifier = new LiopVerifier();
-            const receiptBuf = Buffer.from(data.zk_receipt || "", "base64");
-            const isV2 = receiptBuf.length > 0 && receiptBuf[0] === 2;
-            const isAuthentic = await verifier.verifyZkReceipt(
-              Buffer.from(payload, "utf-8"),
-              data.image_id || "",
-              receiptBuf,
-              {
-                guestImageIdHex: data.guest_image_id,
-                circuitName: data.circuit_name,
-                expectedOutput: data.computation_result,
-                zkPolicy: isV2 ? "required" : "none"
-              }
-            );
-            if (!isAuthentic) {
-              return false;
-            }
-            data.audit_status = isV2 ? "VERIFIED: Groth16 Zero-Knowledge Proof Certified by LiopMcpBridge" : "VERIFIED: ZK-Receipt & ImageID Mathematically Verified by LiopMcpBridge";
-            result.content[0].text = JSON.stringify(data);
-          }
-        } catch {
-        }
-      }
-      return true;
-    } catch (e) {
-      log.info("[LIOP-Bridge] ZK-Verifier Failure:", e);
-      return false;
-    }
-  }
-  /**
-   * Connects the bridge via stdio or Mesh depending on mode.
-   */
-  async connect() {
-    if (this.legacyMcpServer) {
-      const { LiopServer } = await import('./server.js');
-      this.liopServer = new LiopServer(
-        this.options.serverInfo || {
-          name: "liop-bridge",
-          version: "1.0.0"
-        },
-        { security: this.options.security }
-      );
-      if (this.options.publishToMesh) {
-        await this.liopServer.connect();
-        const legacy = this.legacyMcpServer;
-        if (legacy._registeredTools) {
-          for (const [name, tool] of Object.entries(legacy._registeredTools)) {
-            const t = tool;
-            this.liopServer.tool(
-              name,
-              t.description || "",
-              t.inputSchema || {},
-              // biome-ignore lint/suspicious/noExplicitAny: Opaque legacy callback args
-              async (args) => {
-                return await t.handler(args);
-              }
-            );
-          }
-        }
-        if (legacy._registeredResources) {
-          for (const [uri, resource] of Object.entries(
-            legacy._registeredResources
-          )) {
-            const r = resource;
-            this.liopServer.resource(
-              r.name,
-              uri,
-              r.metadata?.description || "",
-              r.metadata?.mimeType || "application/octet-stream",
-              async () => {
-                const res = await r.readCallback(new URL(uri));
-                return res.contents[0].text;
-              }
-            );
-          }
-        }
-      }
-      return;
-    }
-    const readline = await import('readline');
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      terminal: false
-    });
-    const shutdown = async () => {
-      log.info("[LIOP-Bridge] Disconnecting session...");
-      if (this.liopServer) await this.liopServer.close();
-      process.exit(0);
-    };
-    rl.on("close", shutdown);
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    rl.on("line", async (line) => {
-      if (!line.trim()) return;
-      try {
-        const payload = JSON.parse(line);
-        const response = await this.handleJsonRpcRequest(payload);
-        if (response) {
-          process.stdout.write(`${JSON.stringify(response)}
-`);
-        }
-      } catch (e) {
-        log.error(`[LIOP-Bridge] Error: ${e.message}`);
-      }
-    });
-  }
-  getServer() {
-    return this.liopServer;
-  }
-};
-
-export { LiopMcpBridge, LiopStreamBridge };
-//# sourceMappingURL=chunk-WXOWJXY6.js.map
-//# sourceMappingURL=chunk-WXOWJXY6.js.map