trickle-cli 0.1.210 → 0.1.211

package/dist/commands/ci.js

@@ -261,7 +261,7 @@ async function postPrComment(alerts, observations, queries, errors, trickleDir)
             const { runSecurityScan } = require('./security');
             const origLog2 = console.log;
             console.log = () => { };
-            const secResult = runSecurityScan({ dir: trickleDir });
+            const secResult = await runSecurityScan({ dir: trickleDir });
             console.log = origLog2;
             if (secResult.findings.length > 0) {
                 body += `### 🔒 Security\n\n`;

package/dist/commands/compliance.d.ts

@@ -14,4 +14,4 @@
 export declare function generateComplianceReport(opts: {
     json?: boolean;
     out?: string;
-}): void;
+}): Promise<void>;

package/dist/commands/compliance.js

@@ -64,7 +64,7 @@ function readJsonl(fp) {
         return null;
     } }).filter(Boolean);
 }
-function generateComplianceReport(opts) {
+async function generateComplianceReport(opts) {
     const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
     if (!fs.existsSync(dir)) {
         console.log(chalk_1.default.yellow('  No .trickle/ data. Run trickle first.'));
@@ -119,7 +119,7 @@ function generateComplianceReport(opts) {
         const { runSecurityScan } = require('./security');
         const origLog = console.log;
         console.log = () => { };
-        const result = runSecurityScan({ dir });
+        const result = await runSecurityScan({ dir });
         console.log = origLog;
         securityFindings = result.findings.map((f) => ({
             severity: f.severity, category: f.category,

package/dist/commands/demo.js

@@ -165,7 +165,7 @@ async function runDemo() {
         const { runSecurityScan } = require('./security');
         const origLog = console.log;
         console.log = () => { };
-        const sec = runSecurityScan({ dir: path.join(demoDir, '.trickle') });
+        const sec = await runSecurityScan({ dir: path.join(demoDir, '.trickle') });
         console.log = origLog;
         if (sec.findings.length > 0) {
             for (const f of sec.findings.slice(0, 2)) {

package/dist/commands/security.d.ts

@@ -31,5 +31,5 @@ export interface SecurityResult {
 export declare function runSecurityScan(opts?: {
     dir?: string;
     json?: boolean;
-}): SecurityResult;
+}): Promise<SecurityResult>;
 export {};

package/dist/commands/security.js

@@ -86,7 +86,26 @@ const SQLI_PATTERNS = [
     { name: 'OR 1=1', pattern: /OR\s+['"]?1['"]?\s*=\s*['"]?1/i },
     { name: 'Comment injection', pattern: /--\s*$|\/\*.*\*\//i },
     { name: 'DROP/DELETE without WHERE', pattern: /(?:DROP|DELETE\s+FROM)\s+\w+\s*(?:;|$)/i },
+    { name: 'Tautology (always true)', pattern: /WHERE\s+(?:1\s*=\s*1|true|''\s*=\s*'')/i },
+    { name: 'Stacked queries', pattern: /;\s*(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER)\s/i },
+    { name: 'Sleep/benchmark injection', pattern: /(?:SLEEP|BENCHMARK|WAITFOR\s+DELAY|pg_sleep)\s*\(/i },
 ];
+// PII patterns — detect personal data in API responses
+const PII_PATTERNS = [
+    { name: 'Email address', pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/i, severity: 'info' },
+    { name: 'Phone number', pattern: /(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}/, severity: 'info' },
+    { name: 'SSN', pattern: /\b\d{3}[-]?\d{2}[-]?\d{4}\b/, severity: 'critical' },
+    { name: 'Credit card number', pattern: /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})\b/, severity: 'critical' },
+    { name: 'IP address', pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b/, severity: 'info' },
+    { name: 'Password hash', pattern: /\$2[aby]?\$\d{2}\$[./A-Za-z0-9]{53}/, severity: 'warning' },
+];
+// Sensitive field names that shouldn't appear in API responses
+const SENSITIVE_FIELDS = new Set([
+    'password', 'passwd', 'pwd', 'secret', 'token', 'api_key', 'apikey',
+    'api_secret', 'access_token', 'refresh_token', 'private_key',
+    'credit_card', 'card_number', 'cvv', 'cvc', 'ssn', 'social_security',
+    'pin', 'otp', 'auth_token', 'session_id', 'session_token',
+]);
 function scanValue(value, source, location) {
     const findings = [];
     const str = typeof value === 'string' ? value : JSON.stringify(value);
@@ -110,7 +129,29 @@ function scanValue(value, source, location) {
     }
     return findings;
 }
-function runSecurityScan(opts) {
+/**
+ * Recursively extract all field names from a JSON value.
+ */
+function extractFieldNames(obj, prefix = '', depth = 0) {
+    if (depth > 3 || !obj || typeof obj !== 'object')
+        return [];
+    const names = [];
+    if (Array.isArray(obj)) {
+        if (obj.length > 0 && typeof obj[0] === 'object' && obj[0] !== null) {
+            names.push(...extractFieldNames(obj[0], prefix, depth + 1));
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(obj)) {
+            names.push(key);
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                names.push(...extractFieldNames(value, `${key}.`, depth + 1));
+            }
+        }
+    }
+    return names;
+}
+async function runSecurityScan(opts) {
     const trickleDir = opts?.dir || process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
     const findings = [];
     const scanned = { variables: 0, queries: 0, logs: 0, observations: 0 };
@@ -145,8 +186,28 @@ function runSecurityScan(opts) {
     for (const l of logs) {
         findings.push(...scanValue(l.message || l.msg, 'log', l.logger || l.name || 'log'));
     }
-    // Scan function observations (sample I/O)
+    // Scan function observations (sample I/O) — from local file AND backend
     const observations = readJsonl(path.join(trickleDir, 'observations.jsonl'));
+    // Also try to fetch from backend API for richer sample data
+    try {
+        const { getBackendUrl } = require('../config');
+        const backendUrl = getBackendUrl();
+        const res = await fetch(`${backendUrl}/api/mock-config`);
+        if (res.ok) {
+            const { routes } = await res.json();
+            for (const r of routes) {
+                observations.push({
+                    functionName: r.functionName,
+                    module: r.module,
+                    sampleInput: r.sampleInput,
+                    sampleOutput: r.sampleOutput,
+                });
+            }
+        }
+    }
+    catch {
+        // Backend not available — use local data only
+    }
     scanned.observations = observations.length;
     for (const o of observations) {
         if (o.sampleInput)
@@ -154,6 +215,65 @@ function runSecurityScan(opts) {
         if (o.sampleOutput)
             findings.push(...scanValue(o.sampleOutput, 'function_output', `${o.module}.${o.functionName}`));
     }
+    // ── PII in API responses ──
+    // Scan sample outputs for personal data that shouldn't be exposed
+    for (const o of observations) {
+        if (o.sampleOutput) {
+            const outputStr = typeof o.sampleOutput === 'string' ? o.sampleOutput : JSON.stringify(o.sampleOutput);
+            for (const pii of PII_PATTERNS) {
+                if (pii.pattern.test(outputStr)) {
+                    // Skip email pattern for functions that are SUPPOSED to return emails (e.g., user profile)
+                    if (pii.name === 'Email address' || pii.name === 'IP address')
+                        continue; // too noisy for info
+                    findings.push({
+                        severity: pii.severity,
+                        category: 'pii_exposure',
+                        message: `${pii.name} found in API response: ${o.functionName}`,
+                        source: 'function_output',
+                        location: `${o.module}.${o.functionName}`,
+                        evidence: outputStr.substring(0, 60),
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    // ── Sensitive fields in API responses ──
+    // Detect when API responses contain password/token/secret fields
+    for (const o of observations) {
+        if (o.sampleOutput && typeof o.sampleOutput === 'object') {
+            const fields = extractFieldNames(o.sampleOutput);
+            for (const field of fields) {
+                if (SENSITIVE_FIELDS.has(field.toLowerCase())) {
+                    findings.push({
+                        severity: 'critical',
+                        category: 'sensitive_field_exposure',
+                        message: `API response "${o.functionName}" contains sensitive field "${field}"`,
+                        source: 'function_output',
+                        location: `${o.module}.${o.functionName}`,
+                        evidence: `field: ${field}`,
+                    });
+                }
+            }
+        }
+    }
+    // ── Overprivileged responses (excessive data exposure) ──
+    // Flag responses with unusually many fields (potential over-fetching)
+    for (const o of observations) {
+        if (o.sampleOutput && typeof o.sampleOutput === 'object' && !Array.isArray(o.sampleOutput)) {
+            const fields = extractFieldNames(o.sampleOutput);
+            if (fields.length > 20) {
+                findings.push({
+                    severity: 'info',
+                    category: 'excessive_data_exposure',
+                    message: `API response "${o.functionName}" returns ${fields.length} fields — consider returning only what the client needs`,
+                    source: 'function_output',
+                    location: `${o.module}.${o.functionName}`,
+                    evidence: `${fields.length} fields: ${fields.slice(0, 8).join(', ')}...`,
+                });
+            }
+        }
+    }
     // ── Agent Security: The "Lethal Trifecta" ──
     // Scan LLM calls for prompt injection and data exfiltration
     const llmCalls = readJsonl(path.join(trickleDir, 'llm.jsonl'));

package/dist/index.js

@@ -683,7 +683,7 @@ program
     .option("--json", "Structured JSON output")
     .action(async (opts) => {
     const { runSecurityScan } = await Promise.resolve().then(() => __importStar(require("./commands/security")));
-    runSecurityScan({ json: opts.json });
+    await runSecurityScan({ json: opts.json });
 });
 // trickle deps
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-cli",
-  "version": "0.1.210",
+  "version": "0.1.211",
   "description": "Zero-code runtime observability for JS/Python + AI agent debugging. Traces LangChain, CrewAI, OpenAI, Anthropic, Gemini. Eval, security, compliance, cost tracking. Free, local-first.",
   "keywords": ["observability", "tracing", "llm", "openai", "anthropic", "langchain", "crewai", "agent", "mcp", "debugging", "typescript", "python", "security", "eval", "compliance"],
   "bin": {

package/src/commands/ci.ts

@@ -231,7 +231,7 @@ async function postPrComment(
       const { runSecurityScan } = require('./security');
       const origLog2 = console.log;
       console.log = () => {};
-      const secResult = runSecurityScan({ dir: trickleDir });
+      const secResult = await runSecurityScan({ dir: trickleDir });
       console.log = origLog2;
       if (secResult.findings.length > 0) {
         body += `### 🔒 Security\n\n`;

package/src/commands/compliance.ts

@@ -67,7 +67,7 @@ interface ComplianceReport {
   };
 }
 
-export function generateComplianceReport(opts: { json?: boolean; out?: string }): void {
+export async function generateComplianceReport(opts: { json?: boolean; out?: string }): Promise<void> {
   const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
 
   if (!fs.existsSync(dir)) {
@@ -130,7 +130,7 @@ export function generateComplianceReport(opts: { json?: boolean; out?: string })
     const { runSecurityScan } = require('./security');
     const origLog = console.log;
     console.log = () => {};
-    const result = runSecurityScan({ dir });
+    const result = await runSecurityScan({ dir });
     console.log = origLog;
     securityFindings = result.findings.map((f: any) => ({
       severity: f.severity, category: f.category,

package/src/commands/demo.ts

@@ -134,7 +134,7 @@ export async function runDemo(): Promise<void> {
     const { runSecurityScan } = require('./security');
     const origLog = console.log;
     console.log = () => {};
-    const sec = runSecurityScan({ dir: path.join(demoDir, '.trickle') });
+    const sec = await runSecurityScan({ dir: path.join(demoDir, '.trickle') });
     console.log = origLog;
     if (sec.findings.length > 0) {
       for (const f of sec.findings.slice(0, 2)) {

package/src/commands/security.ts

@@ -54,8 +54,29 @@ const SQLI_PATTERNS: Array<{ name: string; pattern: RegExp }> = [
   { name: 'OR 1=1', pattern: /OR\s+['"]?1['"]?\s*=\s*['"]?1/i },
   { name: 'Comment injection', pattern: /--\s*$|\/\*.*\*\//i },
   { name: 'DROP/DELETE without WHERE', pattern: /(?:DROP|DELETE\s+FROM)\s+\w+\s*(?:;|$)/i },
+  { name: 'Tautology (always true)', pattern: /WHERE\s+(?:1\s*=\s*1|true|''\s*=\s*'')/i },
+  { name: 'Stacked queries', pattern: /;\s*(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER)\s/i },
+  { name: 'Sleep/benchmark injection', pattern: /(?:SLEEP|BENCHMARK|WAITFOR\s+DELAY|pg_sleep)\s*\(/i },
 ];
 
+// PII patterns — detect personal data in API responses
+const PII_PATTERNS: Array<{ name: string; pattern: RegExp; severity: SecurityFinding['severity'] }> = [
+  { name: 'Email address', pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/i, severity: 'info' },
+  { name: 'Phone number', pattern: /(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}/, severity: 'info' },
+  { name: 'SSN', pattern: /\b\d{3}[-]?\d{2}[-]?\d{4}\b/, severity: 'critical' },
+  { name: 'Credit card number', pattern: /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})\b/, severity: 'critical' },
+  { name: 'IP address', pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b/, severity: 'info' },
+  { name: 'Password hash', pattern: /\$2[aby]?\$\d{2}\$[./A-Za-z0-9]{53}/, severity: 'warning' },
+];
+
+// Sensitive field names that shouldn't appear in API responses
+const SENSITIVE_FIELDS = new Set([
+  'password', 'passwd', 'pwd', 'secret', 'token', 'api_key', 'apikey',
+  'api_secret', 'access_token', 'refresh_token', 'private_key',
+  'credit_card', 'card_number', 'cvv', 'cvc', 'ssn', 'social_security',
+  'pin', 'otp', 'auth_token', 'session_id', 'session_token',
+]);
+
 function scanValue(value: unknown, source: string, location: string): SecurityFinding[] {
   const findings: SecurityFinding[] = [];
   const str = typeof value === 'string' ? value : JSON.stringify(value);
@@ -80,13 +101,34 @@ function scanValue(value: unknown, source: string, location: string): SecurityFi
   return findings;
 }
 
+/**
+ * Recursively extract all field names from a JSON value.
+ */
+function extractFieldNames(obj: unknown, prefix = '', depth = 0): string[] {
+  if (depth > 3 || !obj || typeof obj !== 'object') return [];
+  const names: string[] = [];
+  if (Array.isArray(obj)) {
+    if (obj.length > 0 && typeof obj[0] === 'object' && obj[0] !== null) {
+      names.push(...extractFieldNames(obj[0], prefix, depth + 1));
+    }
+  } else {
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      names.push(key);
+      if (value && typeof value === 'object' && !Array.isArray(value)) {
+        names.push(...extractFieldNames(value, `${key}.`, depth + 1));
+      }
+    }
+  }
+  return names;
+}
+
 export interface SecurityResult {
   findings: SecurityFinding[];
   scanned: Record<string, number>;
   summary: { critical: number; warning: number; info: number };
 }
 
-export function runSecurityScan(opts?: { dir?: string; json?: boolean }): SecurityResult {
+export async function runSecurityScan(opts?: { dir?: string; json?: boolean }): Promise<SecurityResult> {
   const trickleDir = opts?.dir || process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
   const findings: SecurityFinding[] = [];
   const scanned: Record<string, number> = { variables: 0, queries: 0, logs: 0, observations: 0 };
@@ -125,14 +167,96 @@ export function runSecurityScan(opts?: { dir?: string; json?: boolean }): Securi
     findings.push(...scanValue(l.message || l.msg, 'log', l.logger || l.name || 'log'));
   }
 
-  // Scan function observations (sample I/O)
+  // Scan function observations (sample I/O) — from local file AND backend
   const observations = readJsonl(path.join(trickleDir, 'observations.jsonl'));
+
+  // Also try to fetch from backend API for richer sample data
+  try {
+    const { getBackendUrl } = require('../config');
+    const backendUrl = getBackendUrl();
+    const res = await fetch(`${backendUrl}/api/mock-config`);
+    if (res.ok) {
+      const { routes } = await res.json() as { routes: Array<{ functionName: string; module: string; sampleInput: unknown; sampleOutput: unknown }> };
+      for (const r of routes) {
+        observations.push({
+          functionName: r.functionName,
+          module: r.module,
+          sampleInput: r.sampleInput,
+          sampleOutput: r.sampleOutput,
+        });
+      }
+    }
+  } catch {
+    // Backend not available — use local data only
+  }
+
   scanned.observations = observations.length;
   for (const o of observations) {
     if (o.sampleInput) findings.push(...scanValue(o.sampleInput, 'function_input', `${o.module}.${o.functionName}`));
     if (o.sampleOutput) findings.push(...scanValue(o.sampleOutput, 'function_output', `${o.module}.${o.functionName}`));
   }
 
+  // ── PII in API responses ──
+  // Scan sample outputs for personal data that shouldn't be exposed
+  for (const o of observations) {
+    if (o.sampleOutput) {
+      const outputStr = typeof o.sampleOutput === 'string' ? o.sampleOutput : JSON.stringify(o.sampleOutput);
+      for (const pii of PII_PATTERNS) {
+        if (pii.pattern.test(outputStr)) {
+          // Skip email pattern for functions that are SUPPOSED to return emails (e.g., user profile)
+          if (pii.name === 'Email address' || pii.name === 'IP address') continue; // too noisy for info
+          findings.push({
+            severity: pii.severity,
+            category: 'pii_exposure',
+            message: `${pii.name} found in API response: ${o.functionName}`,
+            source: 'function_output',
+            location: `${o.module}.${o.functionName}`,
+            evidence: outputStr.substring(0, 60),
+          });
+          break;
+        }
+      }
+    }
+  }
+
+  // ── Sensitive fields in API responses ──
+  // Detect when API responses contain password/token/secret fields
+  for (const o of observations) {
+    if (o.sampleOutput && typeof o.sampleOutput === 'object') {
+      const fields = extractFieldNames(o.sampleOutput);
+      for (const field of fields) {
+        if (SENSITIVE_FIELDS.has(field.toLowerCase())) {
+          findings.push({
+            severity: 'critical',
+            category: 'sensitive_field_exposure',
+            message: `API response "${o.functionName}" contains sensitive field "${field}"`,
+            source: 'function_output',
+            location: `${o.module}.${o.functionName}`,
+            evidence: `field: ${field}`,
+          });
+        }
+      }
+    }
+  }
+
+  // ── Overprivileged responses (excessive data exposure) ──
+  // Flag responses with unusually many fields (potential over-fetching)
+  for (const o of observations) {
+    if (o.sampleOutput && typeof o.sampleOutput === 'object' && !Array.isArray(o.sampleOutput)) {
+      const fields = extractFieldNames(o.sampleOutput);
+      if (fields.length > 20) {
+        findings.push({
+          severity: 'info',
+          category: 'excessive_data_exposure',
+          message: `API response "${o.functionName}" returns ${fields.length} fields — consider returning only what the client needs`,
+          source: 'function_output',
+          location: `${o.module}.${o.functionName}`,
+          evidence: `${fields.length} fields: ${fields.slice(0, 8).join(', ')}...`,
+        });
+      }
+    }
+  }
+
   // ── Agent Security: The "Lethal Trifecta" ──
 
   // Scan LLM calls for prompt injection and data exfiltration

package/src/index.ts

@@ -700,7 +700,7 @@ program
   .option("--json", "Structured JSON output")
   .action(async (opts) => {
     const { runSecurityScan } = await import("./commands/security");
-    runSecurityScan({ json: opts.json });
+    await runSecurityScan({ json: opts.json });
   });
 
 // trickle deps