@privacyscrubber/sdk 2.3.9 → 2.4.1

package/examples/python-bridge/privacyscrubber/bridge_daemon.cjs

@@ -0,0 +1,241 @@
+#!/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,
+    output: process.stdout,
+    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.1',
+                    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 options = {
+                    profile: req.profile || engine.defaultProfile,
+                    detectSecrets: req.detect_secrets ?? req.detectSecrets ?? false,
+                    licenseKey: req.license_key || req.licenseKey || engine.licenseKey,
+                    customRules: req.custom_rules || req.customRules || [],
+                    throwOnLimit: req.throw_on_limit ?? req.throwOnLimit ?? true
+                };
+
+                const res = sdk.sanitizeObject(data, options);
+                if (req.persist_session !== false && res.tokenMap) {
+                    Object.assign(engine.sessionMap, res.tokenMap);
+                }
+                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': {
+                sendResponse(id, {
+                    profile: engine.defaultProfile,
+                    license_tier: engine.license?.tier || 'FREE',
+                    is_pro: engine.license?.isPro || false,
+                    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/privacyscrubber/cli.py

@@ -0,0 +1,138 @@
+"""
+PrivacyScrubber Command Line Interface (CLI)
+Zero-Trust Data Sanitization & Local PII Shield for Terminals & Automation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+from privacyscrubber.client import PrivacyScrubberClient, _find_daemon_path
+from privacyscrubber.exceptions import PrivacyScrubberError
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="privacyscrubber",
+        description="PrivacyScrubber ZTDS CLI - Zero-Trust In-Memory PII Redaction (<1ms latency)"
+    )
+    parser.add_argument("--version", action="store_true", help="Print PrivacyScrubber version")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # Command: ping
+    subparsers.add_parser("ping", help="Ping the underlying ZTDS engine and check uptime")
+
+    # Command: status
+    subparsers.add_parser("status", help="Get engine status, memory footprint, and profile")
+
+    # Command: sanitize
+    sanitize_parser = subparsers.add_parser("sanitize", help="Sanitize text or stdin stream")
+    sanitize_parser.add_argument("text", nargs="?", default="", help="Text to sanitize (or pipe via stdin)")
+    sanitize_parser.add_argument("--profile", "-p", default="General", help="Specialized profile (e.g. Healthcare, Financial, Legal)")
+    sanitize_parser.add_argument("--detect-secrets", "-s", action="store_true", help="Detect DevOps and cloud API secrets")
+    sanitize_parser.add_argument("--json", action="store_true", help="Output JSON with token map and telemetry")
+
+    # Command: restore
+    restore_parser = subparsers.add_parser("restore", help="Restore surrogate tokens with cleartext values")
+    restore_parser.add_argument("text", nargs="?", default="", help="Text containing tokens to restore")
+    restore_parser.add_argument("--token-map", "-m", help="JSON string representing token map")
+
+    # Command: daemon
+    daemon_parser = subparsers.add_parser("daemon", help="Run the persistent stdio NDJSON RPC daemon directly")
+    daemon_parser.add_argument("--profile", default="General", help="Default profile")
+    daemon_parser.add_argument("--license-key", default="", help="License key")
+
+    args = parser.parse_args()
+
+    if args.version:
+        print("PrivacyScrubber ZTDS Python SDK v2.4.1")
+        sys.exit(0)
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    if args.command == "daemon":
+        # Launch bridge_daemon.cjs directly with current stdin/stdout
+        daemon_script = _find_daemon_path()
+        node_bin = os.environ.get("PRIVACYSCRUBBER_NODE_PATH", "node")
+        cmd = [node_bin, daemon_script, "--profile", args.profile]
+        if args.license_key:
+            cmd.extend(["--license-key", args.license_key])
+        try:
+            p = subprocess.Popen(cmd)
+            p.wait()
+        except KeyboardInterrupt:
+            pass
+        sys.exit(0)
+
+    # Standard client-based commands
+    try:
+        with PrivacyScrubberClient(default_profile=getattr(args, "profile", "General")) as client:
+            if args.command == "ping":
+                res = client.ping()
+                print(json.dumps(res, indent=2))
+
+            elif args.command == "status":
+                res = client.status()
+                print(json.dumps(res, indent=2))
+
+            elif args.command == "sanitize":
+                text = args.text
+                if not text and not sys.stdin.isatty():
+                    text = sys.stdin.read()
+                if not text:
+                    print("Error: No text provided. Pass as argument or pipe via stdin.", file=sys.stderr)
+                    sys.exit(1)
+
+                res = client.sanitize(
+                    text,
+                    profile=args.profile,
+                    detect_secrets=args.detect_secrets
+                )
+                if args.json:
+                    output = {
+                        "sanitized": res.sanitized,
+                        "token_map": res.token_map,
+                        "count": res.count,
+                        "execution_ms": res.execution_ms,
+                        "telemetry": res.telemetry
+                    }
+                    print(json.dumps(output, indent=2))
+                else:
+                    print(res.sanitized)
+
+            elif args.command == "restore":
+                text = args.text
+                if not text and not sys.stdin.isatty():
+                    text = sys.stdin.read()
+                if not text:
+                    print("Error: No text provided to restore.", file=sys.stderr)
+                    sys.exit(1)
+
+                token_map = None
+                if args.token_map:
+                    try:
+                        token_map = json.loads(args.token_map)
+                    except json.JSONDecodeError as e:
+                        print(f"Error: Invalid JSON token map: {e}", file=sys.stderr)
+                        sys.exit(1)
+
+                res = client.restore(text, token_map=token_map)
+                print(res.restored_text)
+
+    except PrivacyScrubberError as err:
+        print(f"PrivacyScrubber Error: {err}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as err:
+        print(f"Unexpected Error: {err}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()