@hai.ai/jacs 0.6.0

package/mcp.ts

@@ -0,0 +1,521 @@
+// Transport Proxy Pattern - Intercepts at network boundary, not message level
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import jacs from './index.js';
+import { IncomingMessage, ServerResponse } from "node:http";
+
+// Add near the top, after imports:
+const isStdioTransport = (transport: any): boolean => {
+  return transport.constructor.name === 'StdioServerTransport' || 
+         transport.constructor.name === 'StdioClientTransport';
+};
+let enableDiagnosticLogging = false;
+
+function jacslog(...args: any[]): void {
+  console.error(...args);
+}
+
+// Load JACS config only once
+let jacsLoaded = false;
+let jacsLoadError: Error | null = null;
+
+async function ensureJacsLoaded(configPath: string): Promise<void> {
+  if (jacsLoaded) return;
+  if (jacsLoadError) throw jacsLoadError;
+
+  try {
+    jacslog(`ensureJacsLoaded: Attempting to load JACS config from: ${configPath}`);
+    jacsLoadError = null; 
+    await jacs.load(configPath);
+    jacsLoaded = true;
+    jacslog(`ensureJacsLoaded: JACS agent loaded successfully from ${configPath}.`);
+  } catch (error) {
+    jacsLoadError = error as Error;
+    console.error(`ensureJacsLoaded: CRITICAL: Failed to load JACS config from '${configPath}'. Error:`, jacsLoadError.message); 
+    throw jacsLoadError;
+  }
+}
+
+/**
+ * JACS Transport Proxy - Wraps any transport with JACS encryption
+ * 
+ * This proxy sits between the MCP SDK and the actual transport,
+ * intercepting serialized JSON strings (not JSON-RPC objects)
+ */
+export class JACSTransportProxy implements Transport {
+  private jacsOperational = true;
+  private proxyId: string;
+
+  constructor(
+    private transport: Transport,
+    role: "client" | "server",
+    private jacsConfigPath?: string
+  ) {
+    this.proxyId = `JACS_${role.toUpperCase()}_PROXY`;
+    
+    // Disable JACS debugging for STDIO transports to prevent stdout contamination
+    const suppressDebugForStdio = isStdioTransport(transport);
+    const enableDiagnosticLogging = process.env.JACS_MCP_DEBUG === 'true' && !suppressDebugForStdio;
+    
+    if (suppressDebugForStdio) {
+      console.error(`[${this.proxyId}] STDIO transport detected, suppressing debug output`);
+    }
+    
+    jacslog(`[${this.proxyId}] CONSTRUCTOR: Wrapping transport with JACS. Config: ${jacsConfigPath}`);
+
+    if (jacsConfigPath) {
+      ensureJacsLoaded(jacsConfigPath)
+        .then(() => { 
+          this.jacsOperational = true; 
+          jacslog(`[${this.proxyId}] JACS Loaded and operational.`); 
+        })
+        .catch(err => { 
+          this.jacsOperational = false; 
+          console.error(`[${this.proxyId}] JACS Load FAILED:`, err.message); 
+        });
+    } else {
+      this.jacsOperational = false;
+      console.warn(`[${this.proxyId}] No JACS config provided. Operating in passthrough mode.`);
+    }
+
+    // Intercept incoming messages from the transport
+    this.transport.onmessage = async (incomingData: string | JSONRPCMessage | object) => {
+      const logPrefix = `[${this.proxyId}] INCOMING`;
+      
+      try {
+        let messageForSDK: JSONRPCMessage;
+
+        if (typeof incomingData === 'string') {
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: Received string from transport (len ${incomingData.length}): ${incomingData.substring(0,100)}...`);
+          
+          if (this.jacsOperational) {
+            // Try to decrypt/verify the string as a JACS artifact
+            try {
+              if (enableDiagnosticLogging) jacslog(`${logPrefix}: Attempting JACS verification of string...`);
+              const verificationResult = await jacs.verifyResponse(incomingData);
+              
+              let decryptedMessage: JSONRPCMessage;
+              if (verificationResult && typeof verificationResult === 'object' && 'payload' in verificationResult) {
+                decryptedMessage = verificationResult.payload as JSONRPCMessage;
+              } else {
+                decryptedMessage = verificationResult as JSONRPCMessage;
+              }
+              
+              if (enableDiagnosticLogging) jacslog(`${logPrefix}: JACS verification successful. Decrypted message: ${JSON.stringify(decryptedMessage).substring(0,100)}...`);
+              messageForSDK = decryptedMessage;
+            } catch (jacsError) {
+              // Not a JACS artifact, treat as plain JSON
+              const errorMessage = jacsError instanceof Error ? jacsError.message : "Unknown JACS error";
+              if (enableDiagnosticLogging) jacslog(`${logPrefix}: Not a JACS artifact, parsing as plain JSON. JACS error was: ${errorMessage}`);
+              messageForSDK = JSON.parse(incomingData) as JSONRPCMessage;
+            }
+          } else {
+            // JACS not operational, parse as plain JSON
+            if (enableDiagnosticLogging) jacslog(`${logPrefix}: JACS not operational, parsing as plain JSON.`);
+            messageForSDK = JSON.parse(incomingData) as JSONRPCMessage;
+          }
+        } else if (typeof incomingData === 'object' && incomingData !== null && 'jsonrpc' in incomingData) {
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: Received object from transport, using as-is.`);
+          messageForSDK = incomingData as JSONRPCMessage;
+        } else {
+          console.error(`${logPrefix}: Unexpected data type from transport:`, typeof incomingData);
+          throw new Error("Invalid data type from transport");
+        }
+
+        if (enableDiagnosticLogging) jacslog(`${logPrefix}: Passing to MCP SDK: ${JSON.stringify(messageForSDK).substring(0,100)}...`);
+        
+        // Pass the clean JSON-RPC message to the MCP SDK
+        if (this.onmessage) {
+          this.onmessage(messageForSDK);
+        }
+      } catch (error) {
+        console.error(`${logPrefix}: Error processing incoming message:`, error);
+        if (this.onerror) this.onerror(error as Error);
+      }
+    };
+
+    // Forward transport events
+    this.transport.onclose = () => { 
+      jacslog(`[${this.proxyId}] Transport closed.`);
+      if (this.onclose) this.onclose(); 
+    };
+    
+    this.transport.onerror = (error) => { 
+      console.error(`[${this.proxyId}] Transport error:`, error);
+      if (this.onerror) this.onerror(error); 
+    };
+
+    jacslog(`[${this.proxyId}] CONSTRUCTOR: Transport proxy initialized.`);
+
+    if ('send' in this.transport && typeof this.transport.send === 'function') {
+      const originalSend = this.transport.send.bind(this.transport);
+      this.transport.send = async (data: any) => {
+        if (typeof data === 'string') {
+          // Check if this is a server-side SSE transport
+          const sseTransport = this.transport as any;
+          if (sseTransport._sseResponse) {
+            // Server-side: write directly to SSE stream
+            sseTransport._sseResponse.write(`event: message\ndata: ${data}\n\n`);
+            return;
+          } else if (sseTransport._endpoint) {
+            // Client-side: use fetch (existing code)
+            const headers = await (sseTransport._commonHeaders?.() || Promise.resolve({}));
+            const response = await fetch(sseTransport._endpoint, {
+              method: "POST",
+              headers: {
+                ...headers,
+                "content-type": "application/json",
+              },
+              body: data, // Send raw string without JSON.stringify()
+            });
+            if (!response.ok) {
+              const text = await response.text().catch(() => null);
+              throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
+            }
+            return;
+          }
+        }
+        return originalSend(data);
+      };
+    }
+
+    // Replace the client monkey patch section in the constructor with this:
+    if (role === "client") {
+      jacslog(`[${this.proxyId}] Setting up EventSource interception for client...`);
+      
+      // Wait for the transport to be initialized, then intercept its EventSource
+      setTimeout(() => {
+        const sseTransport = this.transport as any;
+        if (sseTransport._eventSource) {
+          jacslog(`[${this.proxyId}] Found EventSource, intercepting onmessage...`);
+          const originalOnMessage = sseTransport._eventSource.onmessage;
+          
+          sseTransport._eventSource.onmessage = async (event: MessageEvent) => {
+            jacslog(`[${this.proxyId}] EventSource received message:`, event.data?.substring(0, 100));
+            
+            try {
+              // Try JACS verification first
+              if (this.jacsOperational) {
+                const verificationResult = await jacs.verifyResponse(event.data);
+                
+                let decryptedMessage: JSONRPCMessage;
+                if (verificationResult && typeof verificationResult === 'object' && 'payload' in verificationResult) {
+                  decryptedMessage = verificationResult.payload as JSONRPCMessage;
+                } else {
+                  decryptedMessage = verificationResult as JSONRPCMessage;
+                }
+                
+                // Clean up JACS-added null values before passing to MCP SDK
+                const cleanedMessage = this.removeNullValues(decryptedMessage);
+                
+                jacslog(`[${this.proxyId}] JACS verification successful, passing decrypted message to MCP SDK`);
+                const newEvent = new MessageEvent('message', {
+                  data: JSON.stringify(cleanedMessage)
+                });
+                originalOnMessage.call(sseTransport._eventSource, newEvent);
+                return;
+              }
+            } catch (jacsError) {
+              jacslog(`[${this.proxyId}] Not a JACS artifact, passing original message to MCP SDK`);
+            }
+            
+            // Not JACS or JACS failed, use original handler
+            originalOnMessage.call(sseTransport._eventSource, event);
+          };
+        } else {
+          jacslog(`[${this.proxyId}] EventSource not found, will retry...`);
+          // Retry after transport is fully initialized
+          setTimeout(() => {
+            if ((this.transport as any)._eventSource) {
+              jacslog(`[${this.proxyId}] Found EventSource on retry, intercepting...`);
+              // Same logic as above
+            }
+          }, 100);
+        }
+      }, 50);
+    }
+  }
+
+  // MCP SDK will set these
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+
+  async start(): Promise<void> { 
+    jacslog(`[${this.proxyId}] Starting underlying transport...`);
+    return this.transport.start(); 
+  }
+  
+  async close(): Promise<void> { 
+    jacslog(`[${this.proxyId}] Closing underlying transport...`);
+    return this.transport.close(); 
+  }
+
+  // Intercept outgoing messages to the transport
+  async send(message: JSONRPCMessage): Promise<void> {
+    const logPrefix = `[${this.proxyId}] OUTGOING`;
+    
+    try {
+      if (enableDiagnosticLogging) jacslog(`${logPrefix}: MCP SDK sending message: ${JSON.stringify(message).substring(0,100)}...`);
+
+      if (this.jacsOperational) {
+        // Skip JACS for error responses
+        if ('error' in message) {
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: Error response, skipping JACS encryption.`);
+          await this.transport.send(message);
+        } else {
+          try {
+            if (enableDiagnosticLogging) jacslog(`${logPrefix}: Applying JACS encryption to message...`);
+            
+            // Clean up the message before JACS signing - remove null params
+            const cleanMessage = { ...message };
+            if ('params' in cleanMessage && cleanMessage.params === null) {
+              delete cleanMessage.params;
+            }
+            
+            const jacsArtifact = await jacs.signRequest(cleanMessage);
+            await this.transport.send(jacsArtifact as any);  
+            
+          } catch (jacsError) {
+            console.error(`${logPrefix}: JACS encryption failed, sending plain message. Error:`, jacsError);
+            await this.transport.send(message);
+          }
+        }
+      } else {
+        if (enableDiagnosticLogging) jacslog(`${logPrefix}: JACS not operational, sending plain message.`);
+        await this.transport.send(message);
+      }
+      
+      if (enableDiagnosticLogging) jacslog(`${logPrefix}: Successfully sent to transport.`);
+    } catch (error) {
+      console.error(`${logPrefix}: Error sending message:`, error);
+      throw error;
+    }
+  }
+
+  // Forward transport properties
+  get sessionId(): string | undefined { 
+    return (this.transport as any).sessionId; 
+  }
+
+  // Handle HTTP POST for SSE transports (if applicable)
+  /**
+   * REQUIRED for SSE (Server-Sent Events) transport pattern in MCP.
+   * 
+   * WHY THIS EXISTS:
+   * SSE is inherently unidirectional (server→client), but MCP requires bidirectional communication.
+   * The MCP SSE implementation solves this with a hybrid approach:
+   * - Server→Client: Uses SSE stream for real-time messages  
+   * - Client→Server: Uses HTTP POST to a specific endpoint
+   * 
+   * This function intercepts those client POST requests, decrypts JACS payloads,
+   * and forwards the decrypted messages to the underlying SSE transport handler.
+   * 
+   * Without this, JACS-encrypted client messages would never reach the MCP server.
+   */
+  async handlePostMessage?(req: IncomingMessage & { auth?: any }, res: ServerResponse, rawBodyString?: string): Promise<void> {
+    const logPrefix = `[${this.proxyId}] HTTP_POST`;
+    
+    // Verify the underlying transport actually supports POST handling
+    // (not all MCP transports do - only SSE transports need this)
+    if (!('handlePostMessage' in this.transport) || typeof this.transport.handlePostMessage !== 'function') {
+      console.error(`${logPrefix}: Underlying transport does not support handlePostMessage`);
+      if (!res.writableEnded) res.writeHead(500).end("Transport does not support POST handling");
+      return;
+    }
+
+    // Extract the request body (which contains the JACS-encrypted payload)
+    let bodyToProcess: string;
+    if (rawBodyString !== undefined) {
+      // Body already provided (likely from Express middleware)
+      bodyToProcess = rawBodyString;
+    } else {
+      // Manually read the request body from the HTTP stream
+      const bodyBuffer = [];
+      for await (const chunk of req) { bodyBuffer.push(chunk); }
+      bodyToProcess = Buffer.concat(bodyBuffer).toString();
+      if (!bodyToProcess) {
+        if (!res.writableEnded) res.writeHead(400).end("Empty body");
+        return;
+      }
+    }
+
+    if (enableDiagnosticLogging) jacslog(`${logPrefix}: Raw body (len ${bodyToProcess.length}): ${bodyToProcess.substring(0,100)}...`);
+
+    // Add this debug line before calling jacs.verifyResponse:
+    jacslog(`${logPrefix}: JACS Debug - Body type: ${typeof bodyToProcess}`);
+    jacslog(`${logPrefix}: JACS Debug - First 200 chars:`, JSON.stringify(bodyToProcess.substring(0, 200)));
+    jacslog(`${logPrefix}: JACS Debug - Is valid JSON?`, (() => {
+      try { JSON.parse(bodyToProcess); return true; } catch { return false; }
+    })());
+
+    try {
+      let processedBody = bodyToProcess;
+
+      if (this.jacsOperational) {
+        // Try normalizing the JSON string before JACS verification:
+        try {
+          // First, try to parse and re-stringify to normalize
+          const parsedJson = JSON.parse(bodyToProcess);
+          const normalizedJsonString = JSON.stringify(parsedJson);
+          
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: Attempting JACS verification with normalized JSON...`);
+          const verificationResult = await jacs.verifyResponse(normalizedJsonString);
+          
+          let decryptedMessage: JSONRPCMessage;
+          if (verificationResult && typeof verificationResult === 'object' && 'payload' in verificationResult) {
+            decryptedMessage = verificationResult.payload as JSONRPCMessage;
+          } else {
+            decryptedMessage = verificationResult as JSONRPCMessage;
+          }
+          
+          // Clean up JACS-added null params before passing to MCP SDK
+          if ('params' in decryptedMessage && decryptedMessage.params === null) {
+            const cleanMessage = { ...decryptedMessage };
+            delete cleanMessage.params;
+            processedBody = JSON.stringify(cleanMessage);
+          } else {
+            processedBody = JSON.stringify(decryptedMessage);
+          }
+          
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: JACS verification successful. Decrypted to: ${processedBody.substring(0,100)}...`);
+        } catch (parseError) {
+          // If it's not valid JSON, try with original string
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: JSON normalization failed, trying original string...`);
+          const verificationResult = await jacs.verifyResponse(bodyToProcess);
+          
+          let decryptedMessage: JSONRPCMessage;
+          if (verificationResult && typeof verificationResult === 'object' && 'payload' in verificationResult) {
+            decryptedMessage = verificationResult.payload as JSONRPCMessage;
+          } else {
+            decryptedMessage = verificationResult as JSONRPCMessage;
+          }
+          
+          // Clean up JACS-added null params before passing to MCP SDK
+          if ('params' in decryptedMessage && decryptedMessage.params === null) {
+            const cleanMessage = { ...decryptedMessage };
+            delete cleanMessage.params;
+            processedBody = JSON.stringify(cleanMessage);
+          } else {
+            processedBody = JSON.stringify(decryptedMessage);
+          }
+          
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: JACS verification successful. Decrypted to: ${processedBody.substring(0,100)}...`);
+        }
+      }
+
+      // Forward to underlying transport's POST handler
+      await this.transport.handlePostMessage(req, res, processedBody);
+      
+    } catch (error) {
+      console.error(`${logPrefix}: Error processing POST:`, error);
+      if (!res.writableEnded) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        res.writeHead(500).end(`Error: ${errorMessage}`);
+      }
+    }
+  }
+
+  private async handleIncomingMessage(incomingData: string | JSONRPCMessage | object): Promise<void> {
+    const logPrefix = `[${this.proxyId}] INCOMING`;
+    
+    try {
+      let messageForSDK: JSONRPCMessage;
+
+      if (typeof incomingData === 'string') {
+        if (enableDiagnosticLogging) jacslog(`${logPrefix}: Received string from transport (len ${incomingData.length}): ${incomingData.substring(0,100)}...`);
+        
+        if (this.jacsOperational) {
+          try {
+            if (enableDiagnosticLogging) jacslog(`${logPrefix}: Attempting JACS verification of string...`);
+            const verificationResult = await jacs.verifyResponse(incomingData);
+            
+            let decryptedMessage: JSONRPCMessage;
+            if (verificationResult && typeof verificationResult === 'object' && 'payload' in verificationResult) {
+              decryptedMessage = verificationResult.payload as JSONRPCMessage;
+            } else {
+              decryptedMessage = verificationResult as JSONRPCMessage;
+            }
+            
+            if (enableDiagnosticLogging) jacslog(`${logPrefix}: JACS verification successful. Decrypted message: ${JSON.stringify(decryptedMessage).substring(0,100)}...`);
+            messageForSDK = decryptedMessage;
+          } catch (jacsError) {
+            const errorMessage = jacsError instanceof Error ? jacsError.message : "Unknown JACS error";
+            if (enableDiagnosticLogging) jacslog(`${logPrefix}: Not a JACS artifact, parsing as plain JSON. JACS error was: ${errorMessage}`);
+            messageForSDK = JSON.parse(incomingData) as JSONRPCMessage;
+          }
+        } else {
+          if (enableDiagnosticLogging) jacslog(`${logPrefix}: JACS not operational, parsing as plain JSON.`);
+          messageForSDK = JSON.parse(incomingData) as JSONRPCMessage;
+        }
+      } else if (typeof incomingData === 'object' && incomingData !== null && 'jsonrpc' in incomingData) {
+        if (enableDiagnosticLogging) jacslog(`${logPrefix}: Received object from transport, using as-is.`);
+        messageForSDK = incomingData as JSONRPCMessage;
+      } else {
+        console.error(`${logPrefix}: Unexpected data type from transport:`, typeof incomingData);
+        throw new Error("Invalid data type from transport");
+      }
+
+      if (enableDiagnosticLogging) jacslog(`${logPrefix}: Passing to MCP SDK: ${JSON.stringify(messageForSDK).substring(0,100)}...`);
+      
+      if (this.onmessage) {
+        this.onmessage(messageForSDK);
+      }
+    } catch (error) {
+      console.error(`${logPrefix}: Error processing incoming message:`, error);
+      if (this.onerror) this.onerror(error as Error);
+    }
+  }
+
+  /**
+   * Removes null and undefined values from JSON objects to prevent MCP schema validation failures.
+   * 
+   * WORKAROUND for MCP JSON Schema validation issues:
+   * - Addresses strict validators (like Anthropic's API) that reject schemas with null values
+   * - Handles edge cases where tools have null inputSchema causing client validation errors
+   * - Prevents "invalid_type: expected object, received undefined" errors in TypeScript SDK v1.9.0
+   * - Cleans up malformed schemas before transmission to avoid -32602 JSON-RPC errors
+   * 
+   * Related issues:
+   * - https://github.com/modelcontextprotocol/typescript-sdk/issues/400 (null schema tools)
+   * - https://github.com/anthropics/claude-code/issues/586 (Anthropic strict Draft 2020-12)
+   * - https://github.com/agno-agi/agno/issues/2791 (missing type field)
+   * 
+   * @param obj - The object to clean (typically MCP tool/resource schemas)
+   * @returns A new object with all null/undefined values recursively removed
+   */
+  private removeNullValues(obj: any): any {
+    if (obj === null || obj === undefined) return undefined;
+    if (typeof obj !== 'object') return obj;
+    if (Array.isArray(obj)) return obj.map(item => this.removeNullValues(item));
+    
+    const cleaned: any = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const cleanedValue = this.removeNullValues(value);
+      if (cleanedValue !== null && cleanedValue !== undefined) {
+        cleaned[key] = cleanedValue;
+      }
+    }
+    return cleaned;
+  }
+}
+
+// Factory functions
+export function createJACSTransportProxy(
+  transport: Transport, 
+  configPath: string,
+  role: "client" | "server"
+): JACSTransportProxy {
+  jacslog(`Creating JACS Transport Proxy for role: ${role}`);
+  return new JACSTransportProxy(transport, role, configPath);
+}
+
+export async function createJACSTransportProxyAsync(
+  transport: Transport,
+  configPath: string,
+  role: "client" | "server"
+): Promise<JACSTransportProxy> {
+  jacslog(`Creating JACS Transport Proxy (async) for role: ${role}`);
+  await ensureJacsLoaded(configPath);
+  return new JACSTransportProxy(transport, role, configPath);
+}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@hai.ai/jacs",
+  "version": "0.6.0",
+  "description": "JACS (JSON Agent Communication Standard) - Data provenance and cryptographic signing for AI agents",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "overrides": {
+    "body-parser": "^2.2.1",
+    "qs": "^6.14.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./simple": {
+      "import": "./simple.js",
+      "require": "./simple.js",
+      "types": "./simple.d.ts"
+    },
+    "./a2a": {
+      "import": "./src/a2a.js",
+      "require": "./src/a2a.js",
+      "types": "./src/a2a.d.ts"
+    },
+    "./mcp": {
+      "import": "./mcp.js",
+      "require": "./mcp.js",
+      "types": "./mcp.d.ts"
+    },
+    "./http": {
+      "import": "./http.js",
+      "require": "./http.js",
+      "types": "./http.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release && npm run build:ts",
+    "build:debug": "napi build --platform && npm run build:ts",
+    "build:ts": "tsc",
+    "test": "JACS_PRIVATE_KEY_PASSWORD='TestP@ss123!#' mocha --timeout 15000 'test/**/*.test.js'",
+    "test:utils": "mocha --timeout 15000 'test/utils.test.js'",
+    "test:agent": "JACS_PRIVATE_KEY_PASSWORD='TestP@ss123!#' mocha --timeout 15000 'test/agent.test.js'",
+    "test:simple": "JACS_PRIVATE_KEY_PASSWORD='TestP@ss123!#' mocha --timeout 15000 'test/simple.test.js'",
+    "test:a2a": "mocha --timeout 15000 'test/a2a.test.js'",
+    "test:integration": "JACS_PRIVATE_KEY_PASSWORD='TestP@ss123!#' mocha --timeout 15000 'test/integration.test.js'"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@napi-rs/cli": "^2.16.3",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15",
+    "chai": "^6.2.2",
+    "mocha": "^11.7.5",
+    "sinon": "^21.0.1",
+    "typescript": "^5.7.0"
+  },
+  "napi": {
+    "name": "jacs",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "x86_64-apple-darwin",
+        "aarch64-apple-darwin"
+      ]
+    }
+  },
+  "author": "HAI.AI",
+  "license": "ISC",
+  "homepage": "https://hai.ai/jacs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HumanAssisted/JACS.git"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "simple.js",
+    "simple.d.ts",
+    "src/a2a.js",
+    "src/a2a.d.ts",
+    "mcp.ts",
+    "mcp.d.ts",
+    "mcp.js",
+    "mcp.js.map",
+    "http.js",
+    "http.d.ts",
+    "jacs.*.node"
+  ],
+  "keywords": [
+    "jacs",
+    "ai",
+    "agent",
+    "signing",
+    "verification",
+    "cryptography",
+    "mcp",
+    "model-context-protocol"
+  ]
+}