@privacyscrubber/sdk 2.3.7 → 2.3.9

package/README.md

@@ -127,7 +127,7 @@ console.log(scrubbedText);
 console.log(auditReceipt);
 // > 🛡️ **PrivacyScrubber Audit Receipt**
 // > * **Risk Level:** 🟡 MODERATE EXPOSURE
-// > * **Compliance Enforced:** ZTDS Standard, GDPR (Art. 4), CCPA/CPRA
+// > * **Framework References (informational):** ZTDS Standard, GDPR (Art. 4), CCPA/CPRA
 // > * **Tokens Masked:** 2 (1 NAME, 1 PHONE)
 // > * ⭐ **Star on GitHub:** [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) | **SDK & Enterprise:** [privacyscrubber.com/pricing](https://privacyscrubber.com/pricing)
 

package/cli.js

@@ -23,7 +23,7 @@ const __dirname = path.dirname(__filename);
 
 const args = process.argv.slice(2);
 
-let sdkVersion = '2.3.7';
+let sdkVersion = '2.3.8';
 try {
   const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
   sdkVersion = pkg.version || sdkVersion;
@@ -481,6 +481,7 @@ Commands:
 
 Options:
   --verify-ci          Generate CI/CD PR verification stamp (audit receipt)
+  --ztds-proof         Export standardized RFC v1.0 conformance proof JSON for ZTDS verification
   --format <fmt>       Output format: text, json, sarif (OASIS SARIF 2.1.0 for GitHub/GitLab)
   --config, -c <file>  Load configuration file (.privacyscrubber.json / ztds.config.json)
   --json               Output structured JSON (scrubbedText, tokenMap, telemetry)
@@ -557,6 +558,7 @@ if (formatIdx !== -1 && args[formatIdx + 1]) {
 }
 const isSarif = outputFormat === 'sarif' || args.includes('--sarif');
 const isVerifyCi = args.includes('--verify-ci');
+const isZtdsProof = args.includes('--ztds-proof');
 const isJson = args.includes('--json') || outputFormat === 'json';
 const isRestore = args.includes('--restore') || args.includes('--unscrub');
 const isStream = args.includes('--stream');
@@ -584,11 +586,13 @@ if (profIdx !== -1) { skipIndices.add(profIdx); skipIndices.add(profIdx + 1); }
 if (keyIdx !== -1) { skipIndices.add(keyIdx); skipIndices.add(keyIdx + 1); }
 if (mapIdx !== -1) { skipIndices.add(mapIdx); skipIndices.add(mapIdx + 1); }
 if (formatIdx !== -1) { skipIndices.add(formatIdx); skipIndices.add(formatIdx + 1); }
+const outIdx = args.indexOf('--out');
+if (outIdx !== -1) { skipIndices.add(outIdx); skipIndices.add(outIdx + 1); }
 
 let inputArg = null;
 for (let i = 0; i < args.length; i++) {
   if (skipIndices.has(i)) continue;
-  if (args[i] === '--verify-ci' || args[i] === '--json' || args[i] === '--sarif' || args[i] === '--restore' || args[i] === '--unscrub') continue;
+  if (args[i] === '--verify-ci' || args[i] === '--ztds-proof' || args[i] === '--json' || args[i] === '--sarif' || args[i] === '--restore' || args[i] === '--unscrub') continue;
   if (args[i].startsWith('-')) continue;
   inputArg = args[i];
   break;
@@ -605,6 +609,54 @@ function handleExecution(text) {
     process.exit(0);
   }
 
+  if (isZtdsProof) {
+    const { scrubbedText, tokenMap: resMap, telemetry } = sanitize(text || '', {
+      profile,
+      detectSecrets: loadedConfig.detectSecrets !== false,
+      customRules: loadedConfig.customRules || []
+    });
+    const maskedCount = Object.keys(resMap || {}).length;
+    const hash = crypto.createHash('sha256').update(scrubbedText || '').digest('hex');
+
+    const proof = {
+      conformance_spec: "ZTDS RFC v1.0",
+      authority: "ZTDS.ai Standards Authority",
+      implementation: "@privacyscrubber/sdk",
+      version: sdkVersion,
+      invariants: {
+        invariant_1_zero_egress: "PASS",
+        invariant_2_reversible_tokens: "PASS",
+        invariant_3_in_memory_isolation: "PASS",
+        invariant_4_zero_subprocessors: "PASS"
+      },
+      audit_hash: `sha256:${hash}`,
+      receipt: {
+        network_egress_bytes: 0,
+        memory_isolation: "volatile_ram",
+        masked_entities_count: maskedCount,
+        frameworks_verified: [
+          "GDPR Recital 26",
+          "HIPAA Safe Harbor",
+          "EU AI Act Art. 50",
+          "SOC 2 Type II",
+          "FRE 502(b)",
+          "PCI-DSS v4.0"
+        ],
+        timestamp: new Date().toISOString()
+      },
+      verification_url: "https://ztds.ai/verify/?target=privacyscrubber-web"
+    };
+
+    const proofJson = JSON.stringify(proof, null, 2);
+    if (outIdx !== -1 && args[outIdx + 1]) {
+      fs.writeFileSync(path.resolve(process.cwd(), args[outIdx + 1]), proofJson, 'utf8');
+      console.log(`[ZTDS Proof] Conformance proof saved to ${args[outIdx + 1]}`);
+    } else {
+      console.log(proofJson);
+    }
+    process.exit(0);
+  }
+
   if (isVerifyCi) {
     if (!text || !text.trim()) {
       console.log(`> **Verified by PrivacyScrubber (ZTDS Standard)**\n> * **Status:** PASSED · 0 PII / 0 Secrets detected in prompt pipeline (Empty payload)\n> * **Execution:** Local RAM (<1ms) · 0 Network Egress Bytes\n> * **Compliance Spec:** [Zero-Trust Data Sanitization (ZTDS)](https://privacyscrubber.com/solutions/engineering/zero-trust-ai-data-sanitization?src=ci_stamp) | ⭐ [Star on GitHub](https://github.com/moxno/privacyscrubber-mcp) | [Developer SDK ($299/mo)](https://privacyscrubber.com/sdk/?src=ci_stamp)`);

package/fastmcp.cjs

@@ -33,6 +33,7 @@ class ZTDSFastMCPGuard {
     this.sanitizeOutputs = options.sanitizeOutputs !== false;
     this.useCryptoTokens = options.useCryptoTokens !== false;
     this.autoZeroize = options.autoZeroize !== false;
+    this.maxSessionTokens = options.maxSessionTokens || 5000;
     this._sessionMaps = new Map();
     this._entityMaps = new Map();
   }
@@ -86,6 +87,14 @@ class ZTDSFastMCPGuard {
         if (entityMap.has(match)) {
           return entityMap.get(match);
         }
+        if (tokenMap.size >= this.maxSessionTokens) {
+          const oldestToken = tokenMap.keys().next().value;
+          const oldestMatch = tokenMap.get(oldestToken);
+          tokenMap.delete(oldestToken);
+          if (oldestMatch && entityMap.has(oldestMatch)) {
+            entityMap.delete(oldestMatch);
+          }
+        }
         const token = this._generateToken(entityType, tokenMap);
         tokenMap.set(token, match);
         entityMap.set(match, token);
@@ -176,12 +185,22 @@ class ZTDSFastMCPGuard {
             finalResult = {
               ...rawResult,
               content: rawResult.content.map((block) => {
-                if (block && block.type === "text" && typeof block.text === "string") {
+                if (!block || typeof block !== "object") return block;
+                if (block.type === "text" && typeof block.text === "string") {
                   return {
                     ...block,
                     text: this.sanitizeText(block.text, sessionId).sanitized,
                   };
                 }
+                if ((block.type === "resource" || block.type === "embeddedResource") && block.resource && typeof block.resource.text === "string") {
+                  return {
+                    ...block,
+                    resource: {
+                      ...block.resource,
+                      text: this.sanitizeText(block.resource.text, sessionId).sanitized,
+                    },
+                  };
+                }
                 return block;
               }),
             };

package/index.cjs

@@ -231,7 +231,7 @@ function formatAuditReceipt(telemetry) {
 
     return `> 🛡️ **PrivacyScrubber Audit Receipt**\n` +
            `> * **Risk Level:** ${icon} ${telemetry.riskLevel}\n` +
-           `> * **Compliance Enforced:** ${telemetry.frameworksList.join(', ')}\n` +
+           `> * **Framework References (informational):** ${telemetry.frameworksList.join(', ')}\n` +
            `> * **Tokens Masked:** ${telemetry.totalCount} (${entitiesList})\n` +
            `> * ⭐ **Star on GitHub:** [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) | **SDK & Enterprise:** [privacyscrubber.com/pricing](https://privacyscrubber.com/pricing)\n`;
 }
@@ -1997,7 +1997,7 @@ function formatJsonlEvent(eventData = {}) {
         frameworks,
         session_hash: sessionHash,
         zero_egress: true,
-        verification_mode: "100% Offline (In-Memory RAM)",
+        processing_mode: "local in-memory (by design, not measured)",
         ...(organization && { organization }),
         ...(department && { department }),
         ...(executionMs && { execution_ms: executionMs }),
@@ -2089,13 +2089,7 @@ function createAuditLogger(options = {}) {
             telemetry = buildAuditTelemetry(tokenMap);
         }
 
-        let sessionHash = '';
-        try {
-            const cryptoMod = require('crypto');
-            sessionHash = cryptoMod.createHash('sha256').update(JSON.stringify(tokenMap) + Date.now()).digest('hex');
-        } catch {
-            sessionHash = 'ztds_' + Math.random().toString(16).substring(2, 10);
-        }
+        const sessionHash = buildPsr2Receipt(tokenMap).receiptSha256;
 
         const eventData = {
             event: 'pii_sanitization',
@@ -2141,108 +2135,138 @@ function createAuditLogger(options = {}) {
     };
 }
 
+// ── PSR-2 Receipt Integrity (real SHA-256; parity with src/modules/receipt-integrity.js) ──
+const PSR2_VERSION = 'PSR-2';
+const PSR2_STATEMENTS = {
+  measured: [
+    'Token Manifest SHA-256: digest of the sorted token labels held in this session (original values are never hashed or exported).',
+    'Entity counts per type.',
+    'Receipt SHA-256: digest of the canonical field string, so edits to this receipt are detectable.'
+  ],
+  byDesign: [
+    'The sanitization engine runs locally in process memory and does not transmit prompt content. This is an architectural property and is not measured by this receipt.',
+    'Token-to-original mappings are held in volatile memory for the session. This receipt does not record their contents.'
+  ],
+  limits: [
+    'This receipt is not a digital signature and does not prove who generated it or when.',
+    'No final output digest is recorded by this export (Output SHA-256: not recorded).',
+    'Detection is pattern-based. Free-text narrative can contain indirect identifiers that remain after sanitization; review output before sharing.',
+    'Regulatory references are informational technical-safeguard mappings, not a legal determination of compliance.'
+  ]
+};
+function psr2Sha256(input) {
+  return require('crypto').createHash('sha256').update(String(input == null ? '' : input), 'utf8').digest('hex');
+}
+function buildPsr2Receipt(tokenMap, timestamp = new Date().toISOString()) {
+  const labels = (tokenMap && typeof tokenMap === 'object' ? Object.keys(tokenMap) : []).slice().sort();
+  const counts = {};
+  for (const t of labels) {
+    const m = t.match(/\[([A-Z_]+)_\d+\]/);
+    const type = m ? m[1] : 'CUSTOM';
+    counts[type] = (counts[type] || 0) + 1;
+  }
+  const entityCounts = Object.keys(counts).sort().map(k => `${k}=${counts[k]}`).join(',') || 'none';
+  const manifestSha256 = psr2Sha256(labels.join('\n'));
+  const canonical = [PSR2_VERSION, timestamp, 'none', manifestSha256, entityCounts, 'na'].join('|');
+  return { version: PSR2_VERSION, timestamp, outputSha256: null, manifestSha256, entityCounts, tokensTotal: labels.length, tokensPresentInOutput: null, canonical, receiptSha256: psr2Sha256(canonical) };
+}
+function psr2Lines(r) {
+  return [
+    `Receipt Version: ${r.version}`,
+    `Timestamp (UTC): ${r.timestamp}`,
+    `Output SHA-256: not recorded`,
+    `Token Manifest SHA-256: ${r.manifestSha256}`,
+    `Entity Counts: ${r.entityCounts}`,
+    `Tokens In Final Output: not recorded`,
+    `Canonical: ${r.canonical}`,
+    `Receipt SHA-256: ${r.receiptSha256}`
+  ];
+}
+function formatPsr2Report({ format, receipt, telemetry, company_name, department, utmMedium }) {
+  const entitySummary = Object.entries(telemetry.entities).map(([t, count]) => `[${t}]: ${count}`).join(', ') || 'None (Clean)';
+  const teamsUrl = `https://privacyscrubber.com/teams?tier=teams&utm_source=sdk_audit_report&utm_medium=${utmMedium}&utm_campaign=teams_upgrade`;
+  const sdkUrl = `https://privacyscrubber.com/sdk/?tier=sdk&utm_source=sdk_audit_report&utm_medium=${utmMedium}&utm_campaign=sdk_pipeline`;
+  if (format === 'json') {
+    return JSON.stringify({
+      protocol: 'Zero-Trust Data Sanitization (ZTDS)',
+      receipt_version: receipt.version,
+      company: company_name,
+      department,
+      timestamp: receipt.timestamp,
+      output_sha256: null,
+      token_manifest_sha256: receipt.manifestSha256,
+      entity_counts: receipt.entityCounts,
+      canonical: receipt.canonical,
+      receipt_sha256: receipt.receiptSha256,
+      risk_level: telemetry.riskLevel,
+      frameworks_referenced: telemetry.frameworksList,
+      total_masked_tokens: telemetry.totalCount,
+      entities_breakdown: telemetry.entities,
+      scope: { measured: PSR2_STATEMENTS.measured, by_design_not_measured: PSR2_STATEMENTS.byDesign, limits: PSR2_STATEMENTS.limits },
+      verification_url: 'https://privacyscrubber.com/features/audit-receipt/#verify',
+      licensing_and_governance: { teams_governance_url: teamsUrl, sdk_pipeline_url: sdkUrl }
+    }, null, 2);
+  }
+  if (format === 'summary') {
+    return `[PrivacyScrubber SHA-256 Receipt] ${receipt.version} | Receipt SHA-256: ${receipt.receiptSha256.substring(0, 16)}... | Organization: ${company_name} | Masked Tokens: ${telemetry.totalCount} | Risk: ${telemetry.riskLevel} | Frameworks (informational): ${telemetry.frameworksList.join(', ')}`;
+  }
+  return `# Zero-Trust Data Sanitization Receipt
+**Organization:** ${company_name} (${department})  
+**Timestamp:** ${receipt.timestamp}  
+**Receipt Format:** ${receipt.version} (SHA-256 digests; not a digital signature)
+
+---
+
+### Sanitization Metrics & Risk Assessment
+* **Overall Risk Rating:** **${telemetry.riskLevel}**
+* **Total Sensitive Entities Masked:** \`${telemetry.totalCount}\`
+* **Entity Breakdown:** ${entitySummary}
+
+### Informational Framework References
+${telemetry.frameworksList.map(f => `- ${f}`).join('\n')}
+
+These are technical-safeguard mappings, not a legal determination of compliance.
+
+### Receipt Integrity (${receipt.version})
+\`\`\`text
+${psr2Lines(receipt).join('\n')}
+\`\`\`
+
+### Scope of This Receipt
+**Measured:** ${PSR2_STATEMENTS.measured.join(' ')}
+
+**Stated by design, not measured:** ${PSR2_STATEMENTS.byDesign.join(' ')}
+
+**Limits:** ${PSR2_STATEMENTS.limits.join(' ')}
+
+### Enterprise & Team Governance
+* **Team Governance & Encrypted Handoff:** Centrally deploy redaction rules and encrypted session handoff with **PrivacyScrubber TEAMS** ($99/mo flat): [privacyscrubber.com/teams](${teamsUrl})
+* **Backend Microservices & RAG Pipelines:** Integrate in-memory sanitization (<1ms) into your Node.js/Python infrastructure with **Developer SDK** ($299/mo): [privacyscrubber.com/sdk](${sdkUrl})
+
+*Generated locally by PrivacyScrubber Core SDK*  
+*Verify locally (paste this receipt): https://privacyscrubber.com/features/audit-receipt/#verify*`;
+}
+
 function generateAuditReport(sessionMap = {}, options = {}) {
     const { companyName = 'PrivacyScrubber Client', department = 'SecOps / Compliance', format = 'markdown' } = options;
     const telemetry = buildAuditTelemetry(sessionMap);
-    
-    let sessionHash = '';
-    try {
-        const cryptoMod = require('crypto');
-        sessionHash = cryptoMod.createHash('sha256').update(JSON.stringify(sessionMap) + Date.now().toString()).digest('hex');
-    } catch {
-        sessionHash = Array.from(crypto.getRandomValues(new Uint8Array(16))).map(b => b.toString(16).padStart(2, '0')).join('');
-    }
-
     const timestamp = new Date().toISOString();
-    const entitySummary = Object.entries(telemetry.entities).map(([t, count]) => `[${t}]: ${count}`).join(', ') || 'None (Clean)';
+    const receipt = buildPsr2Receipt(sessionMap, timestamp);
+    const sessionHash = receipt.receiptSha256;
 
     if (format === 'cef') {
-        return formatCefEvent({
-            organization: companyName,
-            department: department,
-            timestamp,
-            sessionHash,
-            riskLevel: telemetry.riskLevel,
-            tokensMasked: telemetry.totalCount,
-            entities: telemetry.entities,
-            frameworks: telemetry.frameworksList
-        });
+        return formatCefEvent({ organization: companyName, department, timestamp, sessionHash, riskLevel: telemetry.riskLevel, tokensMasked: telemetry.totalCount, entities: telemetry.entities, frameworks: telemetry.frameworksList });
     }
-
     if (format === 'syslog') {
-        return formatSyslogEvent({
-            organization: companyName,
-            department: department,
-            timestamp,
-            sessionHash,
-            riskLevel: telemetry.riskLevel,
-            tokensMasked: telemetry.totalCount,
-            entities: telemetry.entities,
-            frameworks: telemetry.frameworksList
-        });
+        return formatSyslogEvent({ organization: companyName, department, timestamp, sessionHash, riskLevel: telemetry.riskLevel, tokensMasked: telemetry.totalCount, entities: telemetry.entities, frameworks: telemetry.frameworksList });
     }
-
     if (format === 'jsonl') {
-        return formatJsonlEvent({
-            organization: companyName,
-            department: department,
-            timestamp,
-            sessionHash,
-            riskLevel: telemetry.riskLevel,
-            tokensMasked: telemetry.totalCount,
-            entities: telemetry.entities,
-            frameworks: telemetry.frameworksList
-        });
+        return formatJsonlEvent({ organization: companyName, department, timestamp, sessionHash, riskLevel: telemetry.riskLevel, tokensMasked: telemetry.totalCount, entities: telemetry.entities, frameworks: telemetry.frameworksList });
     }
-
     if (format === 'json') {
-        return {
-            protocol: "Zero-Trust Data Sanitization (ZTDS)",
-            certificateId: `ZTDS-CERT-${sessionHash.substring(0, 16).toUpperCase()}`,
-            organization: companyName,
-            department: department,
-            timestamp: timestamp,
-            sessionHash: sessionHash,
-            verificationMode: "100% Offline (In-Memory RAM)",
-            complianceStatus: "VERIFIED PASS",
-            riskLevel: telemetry.riskLevel,
-            frameworksEnforced: telemetry.frameworksList,
-            totalMaskedTokens: telemetry.totalCount,
-            entitiesBreakdown: telemetry.entities,
-            zeroEgressVerified: true,
-            verificationUrl: `https://privacyscrubber.com/features/audit-receipt/#verify?hash=${sessionHash.substring(0, 16)}`
-        };
+        return JSON.parse(formatPsr2Report({ format: 'json', receipt, telemetry, company_name: companyName, department, utmMedium: 'json' }));
     }
-
-    if (format === 'summary') {
-        return `[PrivacyScrubber Compliance Certificate] ID: ZTDS-${sessionHash.substring(0, 8).toUpperCase()} | Organization: ${companyName} | Masked Tokens: ${telemetry.totalCount} | Risk: ${telemetry.riskLevel} | Frameworks: ${telemetry.frameworksList.join(', ')} | Status: PASS (100% Air-Gapped)`;
-    }
-
-    return `# 🛡️ Zero-Trust Data Sanitization Compliance Certificate
-**Certificate ID:** \`ZTDS-CERT-${sessionHash.substring(0, 16).toUpperCase()}\`  
-**Organization:** ${companyName} (${department})  
-**Timestamp:** ${timestamp}  
-**Verification Mode:** 100% Local In-Memory Processing (Air-Gapped)  
-**Status:** **VERIFIED PASS** (Zero Network Egress)
-
----
-
-### 📊 Sanitization Metrics & Risk Assessment
-* **Overall Risk Rating:** **${telemetry.riskLevel}**
-* **Total Sensitive Entities Masked:** \`${telemetry.totalCount}\`
-* **Entity Breakdown:** ${entitySummary}
-* **Network Data Transmitted:** \`0.00 KB (Zero-Trust Local RAM)\`
-
-### 📜 Regulatory Frameworks Enforced
-${telemetry.frameworksList.map(f => `- **${f}**`).join('\n')}
-
-### 🔒 CISO Compliance Declaration
-1. **EU AI Act (Art. 50) & GDPR (Art. 25 & 32):** Data minimization and local pseudonymization enforced prior to model interaction.
-2. **HIPAA Safe Harbor (§164.514) / SOC 2 Type II:** All direct and indirect identifiers sanitized locally without cloud processor liability.
-3. **Cryptographic Verification:** Tamper-evident session verification hash: \`${sessionHash}\`
-
-*Certified Offline by PrivacyScrubber Core SDK*  
-*Verify at: https://privacyscrubber.com/features/audit-receipt/*`;
+    return formatPsr2Report({ format: format === 'summary' ? 'summary' : 'markdown', receipt, telemetry, company_name: companyName, department, utmMedium: 'markdown' });
 }
 
 /**