@dropout-ai/runtime 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dropout-ai/runtime",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Invisible Node.js runtime for capturing AI interactions.",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -9,28 +9,15 @@ const https = require('https');
 const http = require('http');
 const crypto = require('crypto');
 
-// --- CONFIGURATION ---
+// --- DEFAULT CONFIGURATION ---
+const SUPABASE_FUNCTION_URL = "https://hipughmjlwmwjxzyxfzs.supabase.co/functions/v1/capture-sealed";
+
+// Known AI Domains for Auto-Detection
 const KNOWN_AI_DOMAINS = [
-  'api.openai.com',                  // OpenAI
-  'api.anthropic.com',               // Claude
-  'generativelanguage.googleapis.com', // Gemini
-  'aiplatform.googleapis.com',       // Vertex AI (Genkit often uses this)
-  'api.groq.com',                    // Groq
-  'api.mistral.ai',                  // Mistral
-  'api.cohere.ai'                    // Cohere
+  'api.openai.com', 'api.anthropic.com', 'generativelanguage.googleapis.com',
+  'aiplatform.googleapis.com', 'api.groq.com', 'api.mistral.ai', 'api.cohere.ai'
 ];
 
-const DROPOUT_INGEST_URL = "https://hipughmjlwmwjxzyxfzs.supabase.co/functions/v1/capture-sealed";
-
-// --- UTILS ---
-function generateSessionId() {
-  try {
-    return crypto.randomUUID();
-  } catch (e) {
-    return 'sess_' + Math.random().toString(36).substring(2, 12) + Date.now().toString(36);
-  }
-}
-
 class Dropout {
   constructor(config = {}) {
     // 1. Validation
@@ -43,10 +30,11 @@ class Dropout {
     this.config = config;
     this.projectId = config.projectId;
     this.apiKey = config.apiKey;
-    this.debug = config.debug || false; // Toggle this to see logs
+    this.debug = config.debug || false;
     this.privacy = config.privacy || 'full';
+    this.captureEndpoint = SUPABASE_FUNCTION_URL;
 
-    // 3. Singleton Guard (Prevent double-patching)
+    // 3. Singleton Guard
     if (global.__dropout_initialized__) {
       if (this.debug) console.log("[Dropout] ℹ️ Already initialized. Skipping patch.");
       return;
@@ -55,118 +43,239 @@ class Dropout {
 
     // 4. Initialize Identity
     if (!global.__dropout_session_id__) {
-      global.__dropout_session_id__ = generateSessionId();
+      global.__dropout_session_id__ = this.generateSessionId();
     }
 
     // 5. Start the Wiretap
     if (this.debug) console.log(`[Dropout] 🟢 Initialized for Project: ${this.projectId}`);
+
+    // Bind methods to 'this' to avoid scope loss
+    this.log = this.log.bind(this);
+    this.isAiRequest = this.isAiRequest.bind(this);
     this.patchNetwork();
   }
 
+  // --- UTILS ---
   log(msg, ...args) {
     if (this.debug) console.log(`[Dropout] ${msg}`, ...args);
   }
 
-  isAiRequest(url) {
+  generateSessionId() {
+    try {
+      return crypto.randomUUID();
+    } catch (e) {
+      return 'sess_' + Math.random().toString(36).substring(2, 12) + Date.now().toString(36);
+    }
+  }
+
+  hash(text) {
+    if (!text) return null;
+    try {
+      return crypto.createHash('sha256').update(text.toLowerCase().trim()).digest('hex');
+    } catch (e) { return 'hash_err'; }
+  }
+
+  normalize(url, body) {
+    let provider = 'custom';
+    let model = 'unknown';
+
+    if (url) {
+      const u = url.toLowerCase();
+      if (u.includes('openai')) provider = 'openai';
+      else if (u.includes('anthropic')) provider = 'anthropic';
+      else if (u.includes('google') || u.includes('gemini') || u.includes('aiplatform')) provider = 'google';
+      else if (u.includes('groq')) provider = 'groq';
+      else if (u.includes('mistral')) provider = 'mistral';
+      else if (u.includes('cohere')) provider = 'cohere';
+      else if (u.includes('localhost') || u.includes('127.0.0.1')) provider = 'local';
+    }
+
+    if (body) {
+      try {
+        const parsed = typeof body === 'string' ? JSON.parse(body) : body;
+        if (parsed.model) model = parsed.model;
+      } catch (e) { }
+    }
+    return { provider, model };
+  }
+
+  isAiRequest(url, bodyString) {
     if (!url) return false;
-    // Guard: Infinite Loop Prevention (Don't capture our own calls)
-    if (url.includes(DROPOUT_INGEST_URL)) return false;
+    // Guard: Infinite Loop Prevention
+    if (url.includes(this.captureEndpoint)) return false;
+
+    // 1. Check Known Domains
+    if (KNOWN_AI_DOMAINS.some(d => url.includes(d))) return true;
+
+    // 2. Heuristic Check (for custom endpoints)
+    if (bodyString) {
+      return (bodyString.includes('"model"') || bodyString.includes('"messages"')) &&
+        (bodyString.includes('"user"') || bodyString.includes('"prompt"'));
+    }
+    return false;
+  }
+
+  // --- EMITTER ---
+  emit(payload) {
+    // 1. Guard
+    if (!this.apiKey || !this.projectId) return;
+
+    // 2. Construct Payload
+    const finalPayload = {
+      ...payload,
+      project_id: this.projectId,
+      content_blob: payload.content, // Map for new schema
+      content: payload.content,      // Map for old schema (fallback)
+      received_at: new Date().toISOString()
+    };
+
+    this.log(`🚀 Sending Capture (${payload.turn_role})`);
+
+    // 3. Fire and Forget using HTTPS (Bypassing our own patches via pure request)
+    // We use a clean request to avoid triggering our own hooks if we used global.fetch
+    const req = https.request(this.captureEndpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-dropout-key': this.apiKey
+      }
+    });
 
-    // Check against known AI domains
-    return KNOWN_AI_DOMAINS.some(domain => url.includes(domain));
+    req.on('error', (e) => this.log("❌ Upload Failed", e.message));
+    req.write(JSON.stringify(finalPayload));
+    req.end();
   }
 
-  // --- THE CORE: UNIVERSAL PATCHING ---
+  // --- CORE PATCHING ---
   patchNetwork() {
-    const _this = this;
+    const _this = this; // Capture instance
 
-    // A. Patch Global Fetch (Used by OpenAI v4+, Vercel AI SDK, Next.js)
+    // --- A. PATCH FETCH ---
     if (global.fetch) {
       const originalFetch = global.fetch;
       global.fetch = async function (input, init) {
         const url = typeof input === 'string' ? input : input?.url;
 
-        // PASSTHROUGH: If not AI, ignore
-        if (!_this.isAiRequest(url)) {
-          return originalFetch.apply(this, arguments);
+        // Safe Body Check
+        let bodyStr = "";
+        if (init && init.body) {
+          try { bodyStr = typeof init.body === 'string' ? init.body : JSON.stringify(init.body); } catch (e) { }
         }
 
-        _this.log(`⚡ [FETCH] Intercepting request to: ${url}`);
+        // Guard
+        if (!_this.isAiRequest(url, bodyStr)) {
+          return originalFetch.apply(this, arguments);
+        }
 
-        // Capture Request Body
-        let reqBody = "";
-        try { if (init && init.body) reqBody = init.body; } catch (e) { }
+        _this.log(`⚡ [FETCH] Intercepting: ${url}`);
+        const start = Date.now();
+
+        // Emit Request
+        const { provider, model } = _this.normalize(url, bodyStr);
+        _this.emit({
+          session_id: global.__dropout_session_id__,
+          turn_index: 0,
+          turn_role: 'user',
+          provider,
+          model,
+          content: _this.privacy === 'full' ? bodyStr : null,
+          metadata_flags: { method: 'FETCH', url: url }
+        });
 
-        const startTime = Date.now();
+        // Execute
         let response;
-
-        // Execute Original Call
         try {
           response = await originalFetch.apply(this, arguments);
-        } catch (e) { throw e; }
+        } catch (err) { throw err; }
 
-        // Capture Response (Clone response stream)
+        const latency = Date.now() - start;
+
+        // Emit Response
         try {
           const cloned = response.clone();
-          const resBody = await cloned.text();
-
+          const oText = await cloned.text();
           _this.emit({
-            url,
-            method: 'FETCH',
-            request: reqBody,
-            response: resBody,
-            latency: Date.now() - startTime,
-            status: response.status
+            session_id: global.__dropout_session_id__,
+            turn_index: 0,
+            turn_role: 'assistant',
+            latency_ms: latency,
+            provider,
+            model,
+            content: _this.privacy === 'full' ? oText : null,
+            metadata_flags: { status: response.status }
           });
-        } catch (e) { _this.log("⚠️ Error reading response body", e); }
+        } catch (e) { _this.log("⚠️ Failed to read response body"); }
 
         return response;
       };
       this.log("✅ Patch Applied: global.fetch");
     }
 
-    // B. Patch Node HTTPS/HTTP (Used by Axios, Google Vertex SDK, Legacy LangChain)
+    // --- B. PATCH NODE HTTP/HTTPS ---
     const patchNodeRequest = (module, moduleName) => {
       const originalRequest = module.request;
       module.request = function (...args) {
-        // Resolve URL from varied arguments
         let url;
-        let options;
+        // Argument Resolution (url, options, callback) or (options, callback)
         if (typeof args[0] === 'string') {
           url = args[0];
-          options = args[1] || {};
         } else {
-          options = args[0] || {};
-          const protocol = options.protocol || 'https:';
-          const host = options.hostname || options.host || 'localhost';
-          const path = options.path || '/';
+          const opts = args[0] || {};
+          const protocol = opts.protocol || (moduleName === 'https' ? 'https:' : 'http:');
+          const host = opts.hostname || opts.host || 'localhost';
+          const path = opts.path || '/';
           url = `${protocol}//${host}${path}`;
         }
 
-        // PASSTHROUGH: If not AI, ignore
-        if (!_this.isAiRequest(url)) {
+        if (!_this.isAiRequest(url, null)) {
           return originalRequest.apply(this, args);
         }
 
-        _this.log(`⚡ [${moduleName.toUpperCase()}] Intercepting request to: ${url}`);
+        _this.log(`⚡ [${moduleName.toUpperCase()}] Intercepting: ${url}`);
+        const start = Date.now();
 
-        const startTime = Date.now();
         const clientRequest = originalRequest.apply(this, args);
 
-        // Capture Request Body (Chunks)
-        const chunks = [];
+        // Capture Buffers
+        const reqChunks = [];
         const originalWrite = clientRequest.write;
         const originalEnd = clientRequest.end;
 
+        // SAFE WRITE PATCH
         clientRequest.write = function (...writeArgs) {
-          if (writeArgs[0]) chunks.push(Buffer.from(writeArgs[0]));
+          const chunk = writeArgs[0];
+          // Only buffer if it's data (String or Buffer), ignore objects/callbacks
+          if (chunk && (typeof chunk === 'string' || Buffer.isBuffer(chunk))) {
+            reqChunks.push(Buffer.from(chunk));
+          }
           return originalWrite.apply(this, writeArgs);
         };
 
+        // SAFE END PATCH
         clientRequest.end = function (...endArgs) {
-          if (endArgs[0]) chunks.push(Buffer.from(endArgs[0]));
-          // Store full body on the request object for later
-          clientRequest._fullBody = Buffer.concat(chunks).toString('utf8');
+          const chunk = endArgs[0];
+          // Only buffer if it's data
+          if (chunk && (typeof chunk === 'string' || Buffer.isBuffer(chunk))) {
+            reqChunks.push(Buffer.from(chunk));
+          }
+
+          // Emit Request
+          const reqBody = Buffer.concat(reqChunks).toString('utf8');
+          const { provider, model } = _this.normalize(url, reqBody);
+
+          // Attach state to request for response handler
+          clientRequest._dropout_meta = { provider, model };
+
+          _this.emit({
+            session_id: global.__dropout_session_id__,
+            turn_index: 0,
+            turn_role: 'user',
+            provider,
+            model,
+            content: _this.privacy === 'full' ? reqBody : null,
+            metadata_flags: { method: moduleName.toUpperCase(), url: url }
+          });
+
           return originalEnd.apply(this, endArgs);
         };
 
@@ -176,13 +285,18 @@ class Dropout {
           res.on('data', (chunk) => resChunks.push(chunk));
           res.on('end', () => {
             const resBody = Buffer.concat(resChunks).toString('utf8');
+            const latency = Date.now() - start;
+            const meta = clientRequest._dropout_meta || {};
+
             _this.emit({
-              url,
-              method: moduleName.toUpperCase(),
-              request: clientRequest._fullBody,
-              response: resBody,
-              latency: Date.now() - startTime,
-              status: res.statusCode
+              session_id: global.__dropout_session_id__,
+              turn_index: 0,
+              turn_role: 'assistant',
+              latency_ms: latency,
+              provider: meta.provider,
+              model: meta.model,
+              content: _this.privacy === 'full' ? resBody : null,
+              metadata_flags: { status: res.statusCode }
             });
           });
         });
@@ -195,46 +309,15 @@ class Dropout {
     patchNodeRequest(http, 'http');
     this.log("✅ Patch Applied: http/https");
   }
+}
 
-  // --- EMITTER ---
-  emit(data) {
-    // 1. Construct Payload
-    // We combine Request + Response into a single content blob for simplicity in this universal mode
-    const content = `--- REQUEST ---\n${data.request}\n\n--- RESPONSE ---\n${data.response}`;
-
-    const payload = {
-      project_id: this.projectId,
-      session_id: global.__dropout_session_id__,
-      turn_role: 'assistant', // Default to assistant for system-captured logs
-      turn_index: 0, // In universal mode, we capture raw streams
-      //content_blob: this.privacy === 'full' ? content : null,
-      content: this.privacy === 'full' ? content : null,
-      metadata_flags: {
-        latency: data.latency,
-        url: data.url,
-        method: data.method,
-        status: data.status,
-        captured_via: 'universal_interceptor'
-      },
-      received_at: new Date().toISOString()
-    };
-
-    this.log(`🚀 Sending Capture to Supabase (${data.latency}ms)`);
-
-    // 2. Fire and Forget (Using unpatched fetch mechanism)
-    // We use a clean http request to avoid triggering our own hooks if we used global.fetch
-    const req = https.request(DROPOUT_INGEST_URL, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-dropout-key': this.apiKey
-      }
-    });
-
-    req.on('error', (e) => this.log("❌ Upload Failed", e.message));
-    req.write(JSON.stringify(payload));
-    req.end();
-  }
+// Auto-Start (Node Preload)
+if (process.env.DROPOUT_PROJECT_ID && process.env.DROPOUT_API_KEY) {
+  new Dropout({
+    projectId: process.env.DROPOUT_PROJECT_ID,
+    apiKey: process.env.DROPOUT_API_KEY,
+    debug: process.env.DROPOUT_DEBUG === 'true'
+  });
 }
 
 module.exports = Dropout;