@nekzus/liop 1.0.0-alpha.1

package/dist/index-CX43dvMs.d.ts

@@ -0,0 +1,170 @@
+import { L as LiopVerifier } from './verifier-COnid_dg.js';
+import { M as MeshNodeConfig } from './node-B0b2vUFS.js';
+import { EventEmitter } from 'node:events';
+import { M as McpEra, C as CallToolRequest, a as CallToolResult } from './types-lJIxBlWF.js';
+
+interface CertManagerOptions {
+    /** Path to the root CA certificate (PEM format) */
+    rootCertPath?: string;
+    /** Path to the server/client certificate chain (PEM format) */
+    certChainPath: string;
+    /** Path to the private key (PEM format) */
+    privateKeyPath: string;
+    /** Expiration warning threshold in days (default: 30) */
+    warningDays?: number;
+    /** Enable file watching for automatic hot-reloading (default: true) */
+    watchFiles?: boolean;
+    /** Debounce delay in ms for hot reloading (default: 150) */
+    debounceMs?: number;
+}
+interface CertInfo {
+    subject: string;
+    issuer: string;
+    validFrom: string;
+    validTo: string;
+    fingerprint256: string;
+    daysRemaining: number;
+    isExpired: boolean;
+    isExpiringSoon: boolean;
+}
+declare class CertManager extends EventEmitter {
+    private readonly options;
+    private rootCertBuffer;
+    private certChainBuffer;
+    private privateKeyBuffer;
+    private watchers;
+    private reloadDebounceTimer;
+    private readonly warningDays;
+    private readonly debounceMs;
+    constructor(options: CertManagerOptions);
+    /**
+     * Synchronously loads or reloads certificates from filesystem into memory.
+     */
+    loadCertificates(): void;
+    /**
+     * Inspects the loaded server/client certificate chain using Node.js native X509Certificate.
+     */
+    inspectCertificate(): CertInfo;
+    /**
+     * Sets up non-blocking filesystem watchers to detect certificate renewals
+     * and trigger hot-reloading without process restarts.
+     */
+    private setupWatchers;
+    /**
+     * Debounces reload events to ensure files have finished writing.
+     */
+    private scheduleReload;
+    /**
+     * Manually triggers a reload of certificates and emits the 'reload' event.
+     */
+    reload(): CertInfo;
+    getRootCert(): Buffer | null;
+    getCertChain(): Buffer;
+    getPrivateKey(): Buffer;
+    /**
+     * Stops all active file watchers and releases resources.
+     */
+    dispose(): void;
+}
+
+interface LiopTlsOptions {
+    /** Path to the root CA certificate (PEM format) */
+    rootCert?: string;
+    /** Path to the server/client certificate (PEM format) */
+    certChain?: string;
+    /** Path to the private key (PEM format) */
+    privateKey?: string;
+    /** Require mutual TLS (mTLS): verify client certificate against root CA */
+    mutualTls?: boolean;
+    /** Optional CertManager instance for automated certificate management and hot reloading */
+    certManager?: CertManager;
+}
+
+/**
+ * LIOP Client
+ * High-level orchestration for discovery and execution in the Logic-Injection-on-Origin mesh.
+ */
+declare class LiopClient {
+    private meshNode;
+    private rpcClients;
+    private manifests;
+    private tlsOptions?;
+    private serverInfo?;
+    verifier: LiopVerifier;
+    private oauthToken?;
+    private tokenManager?;
+    /** Protocol negotiation era */
+    era: McpEra;
+    /** Negotiated protocol version */
+    protocolVersion: string;
+    constructor(tls?: LiopTlsOptions);
+    /**
+     * Discovers and connects to the target server or mesh capability.
+     * If address is omitted, it sets up the MeshNode to act purely dynamically.
+     */
+    connect(address?: string, options?: {
+        meshConfig?: MeshNodeConfig;
+        auth?: {
+            clientId?: string;
+            clientSecret?: string;
+            nexusUrl?: string;
+            audience?: string;
+            scope?: string;
+            token?: string;
+        };
+    }): Promise<void>;
+    /**
+     * Selects the optimal IP from an array of multiaddrs.
+     * Prioritizes routable non-loopback IPv4 addresses (e.g. Docker bridge, LAN, WAN)
+     * over loopback (127.0.0.1) to prevent inter-container connection failures.
+     */
+    private selectOptimalIp;
+    /**
+     * Dynamically queries Kademlia DHT to find the optimal PeerID providing the Capability
+     * and returns the physical gRPC target (host:port) resolved from the provider's manifest.
+     */
+    resolveCapability(toolName: string): Promise<string>;
+    /**
+     * Probes a remote MCP endpoint using 'server/discover' to negotiate protocol era.
+     * Falls back to legacy initialize handshake if server/discover fails.
+     */
+    probeServerDiscover(mcpUrl: string): Promise<{
+        era: McpEra;
+        protocolVersion: string;
+        supportedVersions: string[];
+    }>;
+    /**
+     * Discovers remote capabilities via the LIOP Manifest Protocol.
+     * Utilizes a memory cache to avoid redundant network dials against live peers.
+     */
+    discoverTools(forceRefresh?: boolean): Promise<{
+        name: string;
+        description?: string;
+    }[]>;
+    /**
+     * Invokes a tool.
+     */
+    callTool(request: CallToolRequest, _wasmPayload?: Buffer): Promise<CallToolResult>;
+    private getOrCreateRpcClient;
+    /**
+     * Reads a specific resource by URI.
+     * In LIOP, resources can be static definitions or dynamic streams.
+     */
+    readResource(uri: string): Promise<{
+        contents: Array<{
+            uri: string;
+            mimeType?: string;
+            text: string;
+        }>;
+    }>;
+    getServerInfo(): {
+        name: string;
+        version: string;
+    } | undefined;
+    /**
+     * Destroys the active Mesh Node resources.
+     */
+    close(): Promise<void>;
+}
+
+export { type CertInfo as C, type LiopTlsOptions as L, CertManager as a, type CertManagerOptions as b, LiopClient as c };