@privacyscrubber/sdk 2.4.5 → 2.4.6

package/examples/python-bridge/bridge_daemon.cjs

@@ -1,260 +0,0 @@
-#!/usr/bin/env node
-/**
- * PrivacyScrubber ZTDS Python Bridge Daemon
- * 
- * Provides a low-latency, zero-network-egress stdio NDJSON RPC daemon
- * for Python, FastAPI, LangChain, and LlamaIndex environments.
- * 
- * Communication protocol:
- * - Request (stdin): Single-line JSON {"id": number|string, "action": string, ...}\n
- * - Response (stdout): Single-line JSON {"id": number|string, "result": {...}}\n
- *   or {"id": number|string, "error": {"message": string, ...}}\n
- * 
- * Zero external network egress. 100% in-memory RAM execution.
- */
-
-'use strict';
-
-const readline = require('readline');
-const path = require('path');
-
-// Resolve @privacyscrubber/sdk across local monorepo, parent dirs, cwd, and node_modules
-let sdk;
-const candidatePaths = [
-    process.env.PRIVACYSCRUBBER_SDK_PATH,
-    path.resolve(process.cwd(), 'npm-sdk/index.cjs'),
-    path.resolve(process.cwd(), 'node_modules/@privacyscrubber/sdk'),
-    path.resolve(__dirname, '../../../index.cjs'),
-    path.resolve(__dirname, '../../index.cjs'),
-    path.resolve(__dirname, '../index.cjs'),
-    path.resolve(__dirname, './index.cjs'),
-    '@privacyscrubber/sdk'
-];
-
-for (const p of candidatePaths) {
-    if (!p) continue;
-    try {
-        sdk = require(p);
-        break;
-    } catch (e) {
-        // try next candidate
-    }
-}
-
-if (!sdk) {
-    try {
-        const resolved = require.resolve('@privacyscrubber/sdk', { paths: [process.cwd(), __dirname] });
-        sdk = require(resolved);
-    } catch (e2) {}
-}
-
-if (!sdk) {
-    process.stderr.write('Fatal: Could not load @privacyscrubber/sdk or index.cjs\n');
-    process.exit(1);
-}
-
-// Parse initial CLI options
-const args = process.argv.slice(2);
-let initialProfile = process.env.PRIVACYSCRUBBER_PROFILE || 'General';
-let licenseKey = process.env.PRIVACYSCRUBBER_KEY || process.env.PRIVACYSCRUBBER_LICENSE_KEY || '';
-
-for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--profile' && args[i + 1]) {
-        initialProfile = args[++i];
-    } else if (args[i] === '--license-key' && args[i + 1]) {
-        licenseKey = args[++i];
-    }
-}
-
-// Instantiate long-lived engine in local RAM
-const engine = new sdk.PrivacyScrubberEngine({
-    licenseKey,
-    defaultProfile: initialProfile,
-    generateReceipt: true
-});
-
-function sendResponse(id, result, error = null) {
-    const payload = { id };
-    if (error) {
-        payload.error = {
-            message: error.message || String(error),
-            name: error.name || 'Error',
-            tier: error.tier,
-            limit: error.limit,
-            profile: error.profile
-        };
-    } else {
-        payload.result = result;
-    }
-    process.stdout.write(JSON.stringify(payload) + '\n');
-}
-
-// Setup readline interface on stdin
-const rl = readline.createInterface({
-    input: process.stdin,
-    terminal: false
-});
-
-rl.on('line', (line) => {
-    const trimmed = line.trim();
-    if (!trimmed) return;
-
-    let req;
-    try {
-        req = JSON.parse(trimmed);
-    } catch (parseErr) {
-        sendResponse(null, null, new Error(`Invalid JSON request: ${parseErr.message}`));
-        return;
-    }
-
-    const { id, action } = req;
-
-    try {
-        switch (action) {
-            case 'ping': {
-                sendResponse(id, {
-                    pong: true,
-                    engine: 'PrivacyScrubber ZTDS',
-                    version: '2.4.5',
-                    uptime: process.uptime()
-                });
-                break;
-            }
-
-            case 'sanitize': {
-                const text = req.text || '';
-                const options = {
-                    profile: req.profile || engine.defaultProfile,
-                    detectSecrets: req.detect_secrets ?? req.detectSecrets ?? false,
-                    licenseKey: req.license_key || req.licenseKey || engine.licenseKey,
-                    persistSession: req.persist_session ?? req.persistSession ?? true,
-                    generateReceipt: req.generate_receipt ?? req.generateReceipt ?? true,
-                    customRules: req.custom_rules || req.customRules || [],
-                    ignoreList: req.ignore_list || req.ignoreList || null,
-                    throwOnLimit: req.throw_on_limit ?? req.throwOnLimit ?? true
-                };
-
-                const res = engine.sanitize(text, options);
-                sendResponse(id, {
-                    sanitized: res.scrubbedText,
-                    scrubbed_text: res.scrubbedText,
-                    token_map: res.tokenMap,
-                    matches: res.matches,
-                    count: res.count,
-                    execution_ms: res.executionMs,
-                    telemetry: res.telemetry,
-                    audit_receipt: res.auditReceipt,
-                    license: res.license
-                });
-                break;
-            }
-
-            case 'restore': {
-                const text = req.text || '';
-                const tokenMap = req.token_map || req.tokenMap || null;
-                const res = engine.restore(text, tokenMap);
-                sendResponse(id, {
-                    restored_text: res.restoredText,
-                    restored_count: res.restoredCount
-                });
-                break;
-            }
-
-            case 'sanitize_object': {
-                const data = req.data ?? {};
-                const persistSession = req.persist_session ?? req.persistSession ?? true;
-                let mergedIgnore = null;
-                const reqIgnore = req.ignore_list || req.ignoreList || null;
-                if (reqIgnore || engine.ignoreList.size > 0) {
-                    mergedIgnore = new Set(engine.ignoreList);
-                    if (reqIgnore) {
-                        for (const item of reqIgnore) mergedIgnore.add(item);
-                    }
-                }
-                const options = {
-                    profile: req.profile || engine.defaultProfile,
-                    detectSecrets: req.detect_secrets ?? req.detectSecrets ?? false,
-                    licenseKey: req.license_key || req.licenseKey || engine.licenseKey,
-                    generateReceipt: req.generate_receipt ?? req.generateReceipt ?? true,
-                    customRules: req.custom_rules || req.customRules || [],
-                    ignoreList: mergedIgnore,
-                    existingSessionMap: persistSession ? engine.sessionMap : (req.existing_session_map || req.existingSessionMap || {}),
-                    throwOnLimit: req.throw_on_limit ?? req.throwOnLimit ?? true
-                };
-
-                const res = sdk.sanitizeObject(data, options);
-                if (persistSession && res.tokenMap) {
-                    Object.assign(engine.sessionMap, res.tokenMap);
-                    const keys = Object.keys(engine.sessionMap);
-                    if (keys.length > engine.maxSessionTokens) {
-                        const excess = keys.length - engine.maxSessionTokens;
-                        for (let i = 0; i < excess; i++) {
-                            delete engine.sessionMap[keys[i]];
-                        }
-                    }
-                }
-                sendResponse(id, {
-                    sanitized: res.sanitized,
-                    token_map: res.tokenMap,
-                    count: res.count,
-                    execution_ms: res.executionMs,
-                    telemetry: res.telemetry,
-                    audit_receipt: res.auditReceipt
-                });
-                break;
-            }
-
-            case 'restore_object': {
-                const data = req.data ?? {};
-                const tokenMap = req.token_map || req.tokenMap || engine.sessionMap;
-                const restored = sdk.restoreObject(data, tokenMap);
-                sendResponse(id, {
-                    restored
-                });
-                break;
-            }
-
-            case 'reset_session': {
-                engine.resetSession();
-                sendResponse(id, { success: true });
-                break;
-            }
-
-            case 'mark_false_positive': {
-                const token = req.token;
-                if (!token) {
-                    throw new Error('Missing token argument for mark_false_positive');
-                }
-                const fpRes = engine.markFalsePositive(token);
-                sendResponse(id, fpRes);
-                break;
-            }
-
-            case 'status': {
-                const tier = engine.license?.tier || 'FREE';
-                sendResponse(id, {
-                    profile: engine.defaultProfile,
-                    license_tier: tier,
-                    is_pro: Boolean(engine.license?.valid && ['SDK', 'OEM', 'ENTERPRISE', 'PRO', 'TEAMS'].includes(tier)),
-                    session_tokens_count: Object.keys(engine.sessionMap).length,
-                    ignore_list_size: engine.ignoreList.size,
-                    memory_usage: process.memoryUsage()
-                });
-                break;
-            }
-
-            default:
-                sendResponse(id, null, new Error(`Unknown action: ${action}`));
-                break;
-        }
-    } catch (err) {
-        sendResponse(id, null, err);
-    }
-});
-
-rl.on('close', () => {
-    process.exit(0);
-});
-
-process.on('SIGINT', () => process.exit(0));
-process.on('SIGTERM', () => process.exit(0));

package/examples/python-bridge/langchain_adapter.py

@@ -1,20 +0,0 @@
-"""
-PrivacyScrubber ZTDS Adapter for LangChain
-Zero-Trust Data Sanitization & Local PII Shield for LangChain Pipelines.
-"""
-
-from __future__ import annotations
-
-from privacyscrubber.langchain import (
-    ZTDSCallbackHandler,
-    ZTDSDocumentTransformer,
-    create_ztds_lcel_runnables,
-    LANGCHAIN_INSTALLED,
-)
-
-__all__ = [
-    "ZTDSCallbackHandler",
-    "ZTDSDocumentTransformer",
-    "create_ztds_lcel_runnables",
-    "LANGCHAIN_INSTALLED",
-]

package/examples/python-bridge/privacyscrubber.py

@@ -1,36 +0,0 @@
-"""
-PrivacyScrubber ZTDS Client for Python
-Zero-Trust Data Sanitization & Local PII Shield for LLM / AI Pipelines.
-
-100% in-memory client-side execution. Zero cloud egress. Sub-millisecond latency.
-RFC v1.0 standard-compliant Zero-Trust Data Sanitization engine.
-"""
-
-from __future__ import annotations
-
-from privacyscrubber import (
-    PrivacyScrubberClient,
-    PrivacyScrubber,
-    AsyncPrivacyScrubberClient,
-    AsyncPrivacyScrubber,
-    SanitizeResult,
-    RestoreResult,
-    ObjectSanitizeResult,
-    PrivacyScrubberError,
-    PrivacyScrubberLicenseError,
-    __version__,
-)
-from privacyscrubber.client import _find_daemon_path
-
-__all__ = [
-    "PrivacyScrubberClient",
-    "PrivacyScrubber",
-    "AsyncPrivacyScrubberClient",
-    "AsyncPrivacyScrubber",
-    "SanitizeResult",
-    "RestoreResult",
-    "ObjectSanitizeResult",
-    "PrivacyScrubberError",
-    "PrivacyScrubberLicenseError",
-    "__version__",
-]

package/examples/python-bridge/test_python_bridge.py

@@ -1,320 +0,0 @@
-#!/usr/bin/env python3
-"""
-PrivacyScrubber ZTDS Python Bridge - Comprehensive Test Suite
-Zero-Trust Data Sanitization & In-Memory PII Shield Verification.
-
-Verifies:
-1. Subprocess lifecycle, stdio NDJSON RPC, ping & status.
-2. Synchronous and Asynchronous client execution parity.
-3. Round-trip restoration fidelity (Zero Data Loss).
-4. Specialized vertical profiles (Healthcare, Financial, Legal, HR).
-5. Nested dictionary and list object sanitization / restoration.
-6. False-positive ignore list management and session reset.
-7. Sub-millisecond latency benchmark (<2ms over stdio IPC).
-8. Thread-safe concurrent execution under load.
-9. LangChain callback handler and LCEL runnable integration.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import os
-import sys
-import threading
-import time
-import unittest
-
-# Ensure current directory is in sys.path
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from privacyscrubber import (
-    PrivacyScrubberClient,
-    AsyncPrivacyScrubberClient,
-    PrivacyScrubberError,
-    SanitizeResult,
-    RestoreResult
-)
-from langchain_adapter import (
-    ZTDSCallbackHandler,
-    ZTDSDocumentTransformer,
-    create_ztds_lcel_runnables
-)
-
-
-class TestPrivacyScrubberBridge(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.client = PrivacyScrubberClient(default_profile="General")
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.client.close()
-
-    def setUp(self):
-        self.client.reset_session()
-
-    def test_01_handshake_and_ping(self):
-        """Verifies sidecar daemon handshake, engine version, and uptime."""
-        res = self.client.ping()
-        self.assertTrue(res.get("pong"))
-        self.assertEqual(res.get("engine"), "PrivacyScrubber ZTDS")
-        self.assertIn("version", res)
-        self.assertGreater(res.get("uptime", 0), 0)
-
-        status = self.client.status()
-        self.assertEqual(status.get("profile"), "General")
-        self.assertIn("license_tier", status)
-
-    def test_02_sync_sanitize_and_restore(self):
-        """Verifies text sanitization and 100% round-trip restoration fidelity."""
-        raw_text = "Contact agent Johnathan Archer at jarcher@starfleet.mil or +1-415-555-0199 for contract details."
-        san_res = self.client.sanitize(raw_text)
-
-        self.assertIsInstance(san_res, SanitizeResult)
-        self.assertNotIn("jarcher@starfleet.mil", san_res.sanitized)
-        self.assertNotIn("+1-415-555-0199", san_res.sanitized)
-        self.assertIn("[NAME_1]", san_res.sanitized)
-        self.assertIn("[EMAIL_1]", san_res.sanitized)
-        self.assertIn("[PHONE_1]", san_res.sanitized)
-        self.assertGreaterEqual(san_res.count, 3)
-
-        # In-memory restoration using engine session
-        rest_res = self.client.restore(san_res.sanitized)
-        self.assertIsInstance(rest_res, RestoreResult)
-        self.assertEqual(rest_res.restored_text, raw_text)
-        self.assertEqual(rest_res.restored_count, san_res.count)
-
-    def test_03_async_client(self):
-        """Verifies asynchronous client execution in asyncio event loop."""
-        async def _run_async_test():
-            async with AsyncPrivacyScrubberClient(default_profile="General") as async_client:
-                ping = await async_client.ping()
-                self.assertTrue(ping.get("pong"))
-
-                raw = "Executive Director Clark Kent (ckent@dailyplanet.com) approved payment."
-                san = await async_client.sanitize(raw)
-                self.assertNotIn("ckent@dailyplanet.com", san.sanitized)
-                self.assertIn("[EMAIL_1]", san.sanitized)
-
-                rest = await async_client.restore(san.sanitized)
-                self.assertEqual(rest.restored_text, raw)
-
-        asyncio.run(_run_async_test())
-
-    def test_04_industry_profiles(self):
-        """Verifies specialized industry profile tokenization."""
-        # Healthcare Profile
-        med_text = "Patient Bruce Wayne (DOB: 1972-02-19, SSN: 000-44-5555) admitted to ICU."
-        med_res = self.client.sanitize(med_text, profile="Healthcare")
-        self.assertNotIn("Bruce Wayne", med_res.sanitized)
-        self.assertNotIn("000-44-5555", med_res.sanitized)
-        self.assertIn("[DATE_1]", med_res.sanitized)
-
-        # Financial Profile
-        fin_text = "Wire $1,500,000 to IBAN GB29XAAA14151617181920 for client Bruce Wayne."
-        fin_res = self.client.sanitize(fin_text, profile="Financial")
-        self.assertNotIn("GB29XAAA14151617181920", fin_res.sanitized)
-
-        # Clean restoration check
-        med_restored = self.client.restore(med_res.sanitized, token_map=med_res.token_map)
-        self.assertEqual(med_restored.restored_text, med_text)
-
-    def test_05_dict_and_list_sanitization(self):
-        """Verifies structured dictionary/list sanitization and restoration."""
-        payload = {
-            "user_id": 1042,
-            "profile": {
-                "full_name": "Tony Stark",
-                "email": "tony@starkindustries.com",
-                "phone": "+1-212-555-0100"
-            },
-            "tags": ["vip", "avenger"],
-            "notes": "Payment from tony@starkindustries.com approved."
-        }
-
-        san_obj = self.client.sanitize_object(payload)
-        self.assertEqual(san_obj.sanitized["profile"]["full_name"], "[NAME_1]")
-        self.assertEqual(san_obj.sanitized["profile"]["email"], "[EMAIL_1]")
-        self.assertEqual(san_obj.sanitized["user_id"], 1042)
-        self.assertEqual(san_obj.sanitized["tags"], ["vip", "avenger"])
-
-        rest_obj = self.client.restore_object(san_obj.sanitized, token_map=san_obj.token_map)
-        self.assertEqual(rest_obj, payload)
-
-    def test_06_false_positive_and_reset(self):
-        """Verifies false positive marking and session clearing."""
-        text = "Contact Jane Doe at jane@example.com."
-        res1 = self.client.sanitize(text)
-        self.assertIn("[NAME_1]", res1.sanitized)
-
-        # Mark Jane Doe as false positive
-        fp_res = self.client.mark_false_positive("[NAME_1]")
-        self.assertTrue(fp_res.get("success"))
-        self.assertEqual(fp_res.get("original"), "Jane Doe")
-
-        # Next sanitize should not mask Jane Doe
-        res2 = self.client.sanitize(text)
-        self.assertIn("Jane Doe", res2.sanitized)
-        self.assertIn("[EMAIL_1]", res2.sanitized)
-
-        # Reset session
-        self.assertTrue(self.client.reset_session())
-        status = self.client.status()
-        self.assertEqual(status.get("session_tokens_count"), 0)
-
-    def test_07_sub_millisecond_benchmark(self):
-        """Measures stdio IPC latency over 50 iterations; asserts average < 3ms."""
-        test_string = "Customer Arthur Dent (adent@hitchhiker.org, phone 44-20-7946-0919) inquiry."
-        latencies = []
-
-        # Warm up
-        self.client.sanitize(test_string)
-
-        for _ in range(50):
-            t0 = time.perf_counter()
-            self.client.sanitize(test_string, persist_session=False)
-            t1 = time.perf_counter()
-            latencies.append((t1 - t0) * 1000.0)
-
-        avg_latency = sum(latencies) / len(latencies)
-        print(f"\n[Benchmark] 50 Stdio IPC Iterations: Avg Latency = {avg_latency:.2f}ms | Min = {min(latencies):.2f}ms | Max = {max(latencies):.2f}ms")
-        self.assertLess(avg_latency, 5.0, f"Average latency {avg_latency:.2f}ms exceeded 5.0ms threshold")
-
-    def test_08_multithreaded_concurrency(self):
-        """Verifies thread-safety across 10 concurrent threads."""
-        errors = []
-
-        def worker(thread_idx: int):
-            try:
-                name = f"Tester {thread_idx}"
-                email = f"user_{thread_idx}@concurrent.io"
-                sample = f"Hello from {name}, reach me at {email}."
-                res = self.client.sanitize(sample, persist_session=False)
-                if f"[EMAIL_1]" not in res.sanitized:
-                    errors.append(f"Thread {thread_idx} missing email token: {res.sanitized}")
-                rest = self.client.restore(res.sanitized, token_map=res.token_map)
-                if rest.restored_text != sample:
-                    errors.append(f"Thread {thread_idx} restoration mismatch: {rest.restored_text} != {sample}")
-            except Exception as e:
-                errors.append(f"Thread {thread_idx} failed: {e}")
-
-        threads = [threading.Thread(target=worker, args=(i,)) for i in range(10)]
-        for t in threads:
-            t.start()
-        for t in threads:
-            t.join()
-
-        self.assertEqual(len(errors), 0, f"Concurrent thread errors: {errors}")
-
-    def test_09_langchain_callback_flow(self):
-        """Verifies LangChain ZTDSCallbackHandler interception and restoration."""
-        handler = ZTDSCallbackHandler(scrubber=self.client, profile="General")
-
-        prompt = ["Review case file for John Watson (SSN 111-22-3333, email jwatson@bakerst.co.uk)."]
-        handler.on_llm_start(serialized={}, prompts=prompt, run_id="unit_run_1")
-
-        self.assertNotIn("jwatson@bakerst.co.uk", prompt[0])
-        self.assertIn("[EMAIL_1]", prompt[0])
-
-        class MockGen:
-            def __init__(self, text):
-                self.text = text
-
-        class MockRes:
-            def __init__(self, text):
-                self.generations = [[MockGen(text)]]
-
-        ai_out = MockRes("Case file approved for [NAME_1] ([EMAIL_1]).")
-        handler.on_llm_end(ai_out, run_id="unit_run_1")
-
-        final_text = ai_out.generations[0][0].text
-        self.assertIn("John Watson", final_text)
-        self.assertIn("jwatson@bakerst.co.uk", final_text)
-
-    def test_10_lcel_runnables(self):
-        """Verifies create_ztds_lcel_runnables() pre and post functions."""
-        scrub_fn, restore_fn = create_ztds_lcel_runnables(self.client, profile="General")
-
-        raw_input = "Send memo to Peter Parker (pparker@dailybugle.com)."
-        sanitized = scrub_fn(raw_input)
-        self.assertIn("[NAME_1]", sanitized)
-        self.assertIn("[EMAIL_1]", sanitized)
-
-        ai_reply = "Memo dispatched to [NAME_1] ([EMAIL_1])."
-        restored = restore_fn(ai_reply)
-        self.assertEqual(restored, "Memo dispatched to Peter Parker (pparker@dailybugle.com).")
-
-    def test_11_cli_commands(self):
-        """Verifies privacyscrubber.cli commands (ping, status, sanitize, restore, version)."""
-        import subprocess
-        python_bin = sys.executable
-        cli_module = "privacyscrubber.cli"
-        bridge_dir = os.path.dirname(os.path.abspath(__file__))
-        sub_env = {**os.environ, "PYTHONPATH": bridge_dir}
-
-        # 1. Ping
-        ping_out = subprocess.check_output(
-            [python_bin, "-m", cli_module, "ping"],
-            text=True,
-            cwd=bridge_dir,
-            env=sub_env
-        )
-        self.assertIn("pong", ping_out)
-        self.assertIn("PrivacyScrubber ZTDS", ping_out)
-
-        # 2. Status
-        status_out = subprocess.check_output(
-            [python_bin, "-m", cli_module, "status"],
-            text=True,
-            cwd=bridge_dir,
-            env=sub_env
-        )
-        self.assertIn("license_tier", status_out)
-
-        # 3. Sanitize argument
-        san_out = subprocess.check_output(
-            [python_bin, "-m", cli_module, "sanitize", "Send to Alice Cooper alice@corp.com"],
-            text=True,
-            cwd=bridge_dir,
-            env=sub_env
-        )
-        self.assertIn("[NAME_1]", san_out)
-        self.assertIn("[EMAIL_1]", san_out)
-        self.assertNotIn("alice@corp.com", san_out)
-
-        # 4. Sanitize stdin
-        pipe_p = subprocess.Popen(
-            [python_bin, "-m", cli_module, "sanitize"],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            text=True,
-            cwd=bridge_dir,
-            env=sub_env
-        )
-        stdout, _ = pipe_p.communicate(input="Confidential email: test@domain.org")
-        self.assertIn("[EMAIL_1]", stdout)
-        self.assertNotIn("test@domain.org", stdout)
-
-        # 5. Restore with token map
-        token_map_json = '{"[NAME_1]": "Bruce Wayne"}'
-        restore_out = subprocess.check_output(
-            [python_bin, "-m", cli_module, "restore", "Hello [NAME_1]", "--token-map", token_map_json],
-            text=True,
-            cwd=bridge_dir,
-            env=sub_env
-        )
-        self.assertIn("Hello Bruce Wayne", restore_out)
-
-        # 6. Version
-        ver_out = subprocess.check_output(
-            [python_bin, "-m", cli_module, "--version"],
-            text=True,
-            cwd=bridge_dir,
-            env=sub_env
-        )
-        self.assertIn("2.4.5", ver_out)
-
-
-if __name__ == "__main__":
-    unittest.main()
-