erosolar-cli 2.1.239 → 2.1.241

package/dist/tools/integrityTools.js

@@ -0,0 +1,1172 @@
+/**
+ * Integrity Verification Tools
+ *
+ * CLI tool suite for cryptographic integrity verification and
+ * legal evidence preservation for pro se litigation.
+ *
+ * Tools:
+ * - IntegrityChain: Create and manage hash chains
+ * - EvidenceCollect: Capture and hash evidence
+ * - IntegrityVerify: Verify chain/record integrity
+ * - ExhibitGenerate: Create legal exhibits with proofs
+ * - FraudDocument: Document fraud indicators
+ * - CryptoHash: General hashing operations
+ * - CryptoSign: Digital signatures
+ */
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import * as https from 'node:https';
+import * as http from 'node:http';
+import { IntegrityVerificationEngine, TECH_COMPANY_TARGETS, FRAUD_TYPES, LEGAL_CITATIONS, hashFile, hashString, documentFraudIndicator, } from '../core/integrityVerification.js';
+// ═══════════════════════════════════════════════════════════════════════════════
+// TOOL SUITE FACTORY
+// ═══════════════════════════════════════════════════════════════════════════════
+export function createIntegrityTools(workingDir = process.cwd()) {
+    // Storage directory for integrity data
+    const integrityDir = path.join(workingDir, '.erosolar', 'integrity');
+    // Key storage
+    let keyPair;
+    const keyPath = path.join(integrityDir, 'keys');
+    // Load or generate keys
+    const loadKeys = async () => {
+        if (keyPair)
+            return keyPair;
+        try {
+            await fs.mkdir(keyPath, { recursive: true });
+            const privKeyPath = path.join(keyPath, 'private.pem');
+            const pubKeyPath = path.join(keyPath, 'public.pem');
+            if (fsSync.existsSync(privKeyPath) && fsSync.existsSync(pubKeyPath)) {
+                keyPair = {
+                    privateKey: await fs.readFile(privKeyPath, 'utf8'),
+                    publicKey: await fs.readFile(pubKeyPath, 'utf8'),
+                };
+            }
+            else {
+                keyPair = IntegrityVerificationEngine.generateKeyPair();
+                await fs.writeFile(privKeyPath, keyPair.privateKey, { mode: 0o600 });
+                await fs.writeFile(pubKeyPath, keyPair.publicKey);
+            }
+            return keyPair;
+        }
+        catch (error) {
+            // Generate ephemeral keys if persistence fails
+            keyPair = IntegrityVerificationEngine.generateKeyPair();
+            return keyPair;
+        }
+    };
+    // Engine instance cache
+    let engineInstance = null;
+    const getEngine = async () => {
+        if (engineInstance)
+            return engineInstance;
+        await fs.mkdir(integrityDir, { recursive: true });
+        const keys = await loadKeys();
+        engineInstance = new IntegrityVerificationEngine({
+            storageDir: integrityDir,
+            algorithm: 'sha256',
+            keyPair: keys,
+        });
+        return engineInstance;
+    };
+    return {
+        id: 'integrity',
+        description: 'Cryptographic integrity verification and legal evidence preservation',
+        tools: [
+            // ─────────────────────────────────────────────────────────────────────────
+            // Chain Management
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'IntegrityChain',
+                description: `Create and manage cryptographic hash chains for evidence preservation.
+
+Operations:
+- create: Initialize a new evidence chain
+- load: Load an existing chain
+- verify: Verify chain integrity
+- export: Export chain with proofs
+- list: List all chains
+
+Hash chains provide tamper-evident logging with:
+- SHA-256/384/512 hashing
+- Chain linkage verification
+- Merkle tree proofs
+- Digital signatures`,
+                parameters: {
+                    type: 'object',
+                    required: ['operation'],
+                    properties: {
+                        operation: {
+                            type: 'string',
+                            enum: ['create', 'load', 'verify', 'export', 'list'],
+                            description: 'Operation to perform',
+                        },
+                        chainId: {
+                            type: 'string',
+                            description: 'Chain identifier (for load/verify/export)',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Human-readable name for new chain',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const operation = args['operation'];
+                    const chainId = args['chainId'];
+                    const engine = await getEngine();
+                    switch (operation) {
+                        case 'create': {
+                            const chain = await engine.createChain(chainId);
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'create',
+                                chain: {
+                                    id: chain.id,
+                                    created: chain.created,
+                                    algorithm: chain.algorithm,
+                                    recordCount: 0,
+                                },
+                                message: `Evidence chain created: ${chain.id}`,
+                            });
+                        }
+                        case 'load': {
+                            if (!chainId) {
+                                return JSON.stringify({ success: false, error: 'chainId required for load' });
+                            }
+                            const chain = await engine.loadChain(chainId);
+                            if (!chain) {
+                                return JSON.stringify({ success: false, error: `Chain not found: ${chainId}` });
+                            }
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'load',
+                                chain: {
+                                    id: chain.id,
+                                    created: chain.created,
+                                    lastModified: chain.lastModified,
+                                    algorithm: chain.algorithm,
+                                    recordCount: chain.records.length,
+                                    merkleRoot: chain.merkleTree.root,
+                                },
+                            });
+                        }
+                        case 'verify': {
+                            if (!chainId) {
+                                return JSON.stringify({ success: false, error: 'chainId required for verify' });
+                            }
+                            await engine.loadChain(chainId);
+                            const result = engine.verifyChainIntegrity(chainId);
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'verify',
+                                chainId,
+                                integrity: {
+                                    valid: result.valid,
+                                    verifiedRecords: result.verifiedRecords,
+                                    errors: result.errors,
+                                },
+                            });
+                        }
+                        case 'export': {
+                            if (!chainId) {
+                                return JSON.stringify({ success: false, error: 'chainId required for export' });
+                            }
+                            await engine.loadChain(chainId);
+                            const bundle = await engine.exportChainBundle(chainId);
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'export',
+                                bundle: {
+                                    chainId: bundle.chain.id,
+                                    recordCount: bundle.chain.records.length,
+                                    merkleRoot: bundle.chain.merkleTree.root,
+                                    verification: bundle.verification,
+                                },
+                            });
+                        }
+                        case 'list': {
+                            const chainsDir = path.join(integrityDir, 'chains');
+                            try {
+                                const dirs = await fs.readdir(chainsDir);
+                                const chains = [];
+                                for (const dir of dirs) {
+                                    try {
+                                        const chainPath = path.join(chainsDir, dir, 'chain.json');
+                                        const data = await fs.readFile(chainPath, 'utf8');
+                                        const chain = JSON.parse(data);
+                                        chains.push({
+                                            id: chain.id,
+                                            created: chain.created,
+                                            lastModified: chain.lastModified,
+                                            recordCount: chain.records?.length || 0,
+                                        });
+                                    }
+                                    catch {
+                                        // Skip invalid chains
+                                    }
+                                }
+                                return JSON.stringify({ success: true, operation: 'list', chains });
+                            }
+                            catch {
+                                return JSON.stringify({ success: true, operation: 'list', chains: [] });
+                            }
+                        }
+                        default:
+                            return JSON.stringify({ success: false, error: `Unknown operation: ${operation}` });
+                    }
+                },
+            },
+            // ─────────────────────────────────────────────────────────────────────────
+            // Evidence Collection
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'EvidenceCollect',
+                description: `Collect and cryptographically hash evidence for legal preservation.
+
+Supports collecting:
+- Files (documents, images, binaries)
+- URLs (web pages, API responses)
+- Text content (messages, logs)
+- Screenshots
+- Network traffic captures
+
+Each piece of evidence is:
+- Hashed with SHA-256
+- Linked to previous evidence (chain)
+- Timestamped
+- Digitally signed
+- Stored with full metadata
+
+Target entities (auto-populated info available):
+- apple, google, meta, microsoft, amazon`,
+                parameters: {
+                    type: 'object',
+                    required: ['chainId', 'evidenceType', 'source'],
+                    properties: {
+                        chainId: {
+                            type: 'string',
+                            description: 'Evidence chain to add to',
+                        },
+                        evidenceType: {
+                            type: 'string',
+                            enum: [
+                                'communication', 'transaction', 'terms_violation', 'privacy_breach',
+                                'data_manipulation', 'api_response', 'screenshot', 'document',
+                                'metadata', 'network_traffic', 'audit_log', 'configuration',
+                                'binary_artifact', 'fraud_indicator',
+                            ],
+                            description: 'Type of evidence being collected',
+                        },
+                        source: {
+                            type: 'string',
+                            description: 'Source: file path, URL, or "inline" for direct content',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Direct content (when source is "inline")',
+                        },
+                        target: {
+                            type: 'string',
+                            description: 'Target entity (apple, google, meta, microsoft, amazon) or custom name',
+                        },
+                        targetProduct: {
+                            type: 'string',
+                            description: 'Specific product (e.g., "iOS", "Gmail", "Facebook")',
+                        },
+                        legalBasis: {
+                            type: 'string',
+                            description: 'Legal basis for evidence (e.g., "FTC Act Section 5")',
+                        },
+                        jurisdiction: {
+                            type: 'string',
+                            description: 'Legal jurisdiction (e.g., "Federal", "California")',
+                        },
+                        caseReference: {
+                            type: 'string',
+                            description: 'Case reference number if applicable',
+                        },
+                        collector: {
+                            type: 'string',
+                            description: 'Name of person collecting evidence',
+                        },
+                        notes: {
+                            type: 'string',
+                            description: 'Additional notes about the evidence',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const chainId = args['chainId'];
+                    const evidenceType = args['evidenceType'];
+                    const source = args['source'];
+                    const content = args['content'];
+                    const targetName = args['target'];
+                    const targetProduct = args['targetProduct'];
+                    const legalBasis = args['legalBasis'] || 'Investigation';
+                    const jurisdiction = args['jurisdiction'] || 'Federal';
+                    const caseReference = args['caseReference'];
+                    const collector = args['collector'] || 'erosolar-cli';
+                    const notes = args['notes'];
+                    const engine = await getEngine();
+                    await engine.loadChain(chainId);
+                    // Build target entity
+                    let targetEntity;
+                    const companyInfo = targetName ? TECH_COMPANY_TARGETS[targetName.toLowerCase()] : undefined;
+                    if (companyInfo) {
+                        targetEntity = {
+                            name: companyInfo.company,
+                            type: 'corporation',
+                            identifiers: {
+                                legalName: companyInfo.corporateInfo.legalName,
+                                headquarters: companyInfo.corporateInfo.headquarters,
+                                secFilings: companyInfo.corporateInfo.secFilings || '',
+                                incorporationState: companyInfo.corporateInfo.incorporationState || '',
+                            },
+                        };
+                        if (targetProduct) {
+                            const product = companyInfo.products.find(p => p.name.toLowerCase() === targetProduct.toLowerCase());
+                            if (product) {
+                                targetEntity = {
+                                    name: product.name,
+                                    type: 'product',
+                                    identifiers: {
+                                        productType: product.type,
+                                        dataTypes: product.dataTypes.join(', '),
+                                    },
+                                    parent: companyInfo.company,
+                                };
+                            }
+                        }
+                    }
+                    else {
+                        targetEntity = {
+                            name: targetName || 'Unknown',
+                            type: 'corporation',
+                            identifiers: {},
+                        };
+                    }
+                    // Get content based on source
+                    let evidenceContent;
+                    let mimeType;
+                    let captureMethod;
+                    let sourceUrl;
+                    if (source === 'inline') {
+                        if (!content) {
+                            return JSON.stringify({ success: false, error: 'Content required for inline source' });
+                        }
+                        evidenceContent = content;
+                        captureMethod = 'direct_input';
+                    }
+                    else if (source.startsWith('http://') || source.startsWith('https://')) {
+                        // Fetch URL content
+                        sourceUrl = source;
+                        try {
+                            evidenceContent = await fetchUrl(source);
+                            captureMethod = 'url_fetch';
+                            mimeType = 'text/html';
+                        }
+                        catch (error) {
+                            return JSON.stringify({
+                                success: false,
+                                error: `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`,
+                            });
+                        }
+                    }
+                    else {
+                        // Read file
+                        try {
+                            evidenceContent = await fs.readFile(source);
+                            captureMethod = 'file_read';
+                            mimeType = getMimeType(source);
+                        }
+                        catch (error) {
+                            return JSON.stringify({
+                                success: false,
+                                error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+                            });
+                        }
+                    }
+                    const record = await engine.collectEvidence({
+                        chainId,
+                        target: targetEntity,
+                        evidenceType,
+                        content: evidenceContent,
+                        mimeType,
+                        sourceUrl,
+                        captureMethod,
+                        legalBasis,
+                        jurisdiction,
+                        caseReference,
+                        collector,
+                        notes,
+                    });
+                    return JSON.stringify({
+                        success: true,
+                        record: {
+                            id: record.id,
+                            timestamp: record.timestamp,
+                            contentHash: record.contentHash,
+                            previousHash: record.previousHash,
+                            merkleRoot: record.merkleRoot,
+                            signed: !!record.signature,
+                            target: record.metadata.target.name,
+                            evidenceType: record.metadata.evidenceType,
+                        },
+                        message: `Evidence collected and hashed: ${record.contentHash.slice(0, 16)}...`,
+                    });
+                },
+            },
+            // ─────────────────────────────────────────────────────────────────────────
+            // Integrity Verification
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'IntegrityVerify',
+                description: `Verify cryptographic integrity of evidence chains and records.
+
+Verification includes:
+- Content hash verification
+- Chain linkage verification
+- Merkle tree proof verification
+- Digital signature verification
+- Timestamp validation
+
+Returns detailed verification report suitable for court submission.`,
+                parameters: {
+                    type: 'object',
+                    required: ['chainId'],
+                    properties: {
+                        chainId: {
+                            type: 'string',
+                            description: 'Chain to verify',
+                        },
+                        recordId: {
+                            type: 'string',
+                            description: 'Specific record to verify (optional)',
+                        },
+                        generateProof: {
+                            type: 'boolean',
+                            description: 'Generate Merkle proof for record',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const chainId = args['chainId'];
+                    const recordId = args['recordId'];
+                    const generateProof = args['generateProof'];
+                    const engine = await getEngine();
+                    await engine.loadChain(chainId);
+                    const result = engine.verifyChainIntegrity(chainId);
+                    const response = {
+                        success: true,
+                        chainId,
+                        verification: {
+                            valid: result.valid,
+                            verifiedRecords: result.verifiedRecords,
+                            errors: result.errors,
+                            timestamp: new Date().toISOString(),
+                        },
+                    };
+                    if (recordId && generateProof) {
+                        const proof = engine.generateMerkleProof(chainId, recordId);
+                        if (proof) {
+                            const proofValid = engine.verifyMerkleProof(proof);
+                            response['merkleProof'] = {
+                                recordId: proof.recordId,
+                                leafHash: proof.leafHash,
+                                rootHash: proof.rootHash,
+                                siblingCount: proof.siblings.length,
+                                verified: proofValid,
+                            };
+                        }
+                    }
+                    return JSON.stringify(response);
+                },
+            },
+            // ─────────────────────────────────────────────────────────────────────────
+            // Legal Exhibit Generation
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'ExhibitGenerate',
+                description: `Generate legal exhibits with cryptographic integrity proofs.
+
+Creates court-ready exhibits including:
+- Exhibit metadata and numbering
+- Full chain of custody documentation
+- Merkle proofs for each piece of evidence
+- Digital signatures and timestamps
+- Integrity verification summary
+
+Output formats: JSON, HTML (for printing)`,
+                parameters: {
+                    type: 'object',
+                    required: ['chainId', 'exhibitNumber', 'title'],
+                    properties: {
+                        chainId: {
+                            type: 'string',
+                            description: 'Evidence chain to generate exhibit from',
+                        },
+                        exhibitNumber: {
+                            type: 'string',
+                            description: 'Exhibit number (e.g., "A", "1", "Plaintiff-1")',
+                        },
+                        title: {
+                            type: 'string',
+                            description: 'Exhibit title',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Exhibit description',
+                        },
+                        recordIds: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Specific record IDs to include (default: all)',
+                        },
+                        format: {
+                            type: 'string',
+                            enum: ['json', 'html'],
+                            description: 'Output format',
+                        },
+                        outputPath: {
+                            type: 'string',
+                            description: 'Path to write exhibit file',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const chainId = args['chainId'];
+                    const exhibitNumber = args['exhibitNumber'];
+                    const title = args['title'];
+                    const description = args['description'] || '';
+                    const recordIds = args['recordIds'];
+                    const format = args['format'] || 'json';
+                    const outputPath = args['outputPath'];
+                    const engine = await getEngine();
+                    await engine.loadChain(chainId);
+                    const exhibit = await engine.generateExhibit({
+                        chainId,
+                        exhibitNumber,
+                        title,
+                        description,
+                        recordIds,
+                        format,
+                    });
+                    let output;
+                    if (format === 'html') {
+                        output = generateHtmlExhibit(exhibit);
+                    }
+                    else {
+                        output = JSON.stringify(exhibit, null, 2);
+                    }
+                    if (outputPath) {
+                        await fs.writeFile(outputPath, output);
+                    }
+                    return JSON.stringify({
+                        success: true,
+                        exhibit: {
+                            exhibitNumber: exhibit.exhibitNumber,
+                            title: exhibit.title,
+                            chainId: exhibit.chainId,
+                            recordCount: exhibit.recordIds.length,
+                            merkleRoot: exhibit.integrityProof.rootHash,
+                            custodyEntries: exhibit.chainOfCustody.length,
+                            generated: exhibit.generated,
+                            format,
+                            outputPath: outputPath || null,
+                        },
+                        message: `Legal exhibit ${exhibitNumber} generated with ${exhibit.recordIds.length} evidence records`,
+                    });
+                },
+            },
+            // ─────────────────────────────────────────────────────────────────────────
+            // Fraud Documentation
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'FraudDocument',
+                description: `Document fraud indicators with legal citations.
+
+Pre-defined fraud types:
+- DATA_MANIPULATION: Unauthorized modification of user data
+- PRIVACY_VIOLATION: Collection/use beyond stated purposes
+- TERMS_VIOLATION: Provider breach of ToS
+- MISREPRESENTATION: False/misleading statements
+- ANTICOMPETITIVE: Anti-competitive practices
+- SECURITY_NEGLIGENCE: Failure to protect data
+- BILLING_FRAUD: Unauthorized charges
+- CONSENT_VIOLATION: Action without consent
+- DISCRIMINATION: Algorithmic discrimination
+- CENSORSHIP: Improper content moderation
+
+Auto-suggests relevant legal citations (FTC Act, CCPA, CFAA, etc.)`,
+                parameters: {
+                    type: 'object',
+                    required: ['chainId', 'fraudType', 'description'],
+                    properties: {
+                        chainId: {
+                            type: 'string',
+                            description: 'Evidence chain to add fraud indicator to',
+                        },
+                        fraudType: {
+                            type: 'string',
+                            enum: Object.keys(FRAUD_TYPES),
+                            description: 'Type of fraud',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Detailed description of the fraud',
+                        },
+                        severity: {
+                            type: 'string',
+                            enum: ['low', 'medium', 'high', 'critical'],
+                            description: 'Severity level',
+                        },
+                        evidenceRecordIds: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'IDs of evidence records supporting this fraud indicator',
+                        },
+                        legalCitation: {
+                            type: 'string',
+                            description: 'Specific legal citation (auto-suggested if not provided)',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const chainId = args['chainId'];
+                    const fraudType = args['fraudType'];
+                    const description = args['description'];
+                    const severity = args['severity'] || 'medium';
+                    const evidenceRecordIds = args['evidenceRecordIds'] || [];
+                    let legalCitation = args['legalCitation'];
+                    // Auto-suggest legal citation based on fraud type
+                    if (!legalCitation) {
+                        const citationMap = {
+                            DATA_MANIPULATION: LEGAL_CITATIONS.COMPUTER_FRAUD,
+                            PRIVACY_VIOLATION: LEGAL_CITATIONS.CCPA,
+                            TERMS_VIOLATION: LEGAL_CITATIONS.FTC_ACT_SECTION_5,
+                            MISREPRESENTATION: LEGAL_CITATIONS.LANHAM_ACT,
+                            ANTICOMPETITIVE: LEGAL_CITATIONS.SHERMAN_ACT,
+                            SECURITY_NEGLIGENCE: LEGAL_CITATIONS.FTC_ACT_SECTION_5,
+                            BILLING_FRAUD: LEGAL_CITATIONS.WIRE_FRAUD,
+                            CONSENT_VIOLATION: LEGAL_CITATIONS.ECPA,
+                            DISCRIMINATION: LEGAL_CITATIONS.FTC_ACT_SECTION_5,
+                            CENSORSHIP: LEGAL_CITATIONS.FTC_ACT_SECTION_5,
+                        };
+                        legalCitation = citationMap[fraudType] || LEGAL_CITATIONS.FTC_ACT_SECTION_5;
+                    }
+                    const indicator = documentFraudIndicator({
+                        type: fraudType,
+                        description,
+                        severity,
+                        evidenceRefs: evidenceRecordIds,
+                        legalCitation,
+                    });
+                    // Store as evidence
+                    const engine = await getEngine();
+                    await engine.loadChain(chainId);
+                    const record = await engine.collectEvidence({
+                        chainId,
+                        target: {
+                            name: 'Fraud Indicator',
+                            type: 'system',
+                            identifiers: { type: fraudType },
+                        },
+                        evidenceType: 'fraud_indicator',
+                        content: JSON.stringify(indicator),
+                        mimeType: 'application/json',
+                        captureMethod: 'fraud_documentation',
+                        legalBasis: legalCitation,
+                        jurisdiction: 'Federal',
+                        collector: 'erosolar-cli',
+                        notes: `Fraud type: ${FRAUD_TYPES[fraudType]}`,
+                    });
+                    return JSON.stringify({
+                        success: true,
+                        fraudIndicator: {
+                            recordId: record.id,
+                            type: fraudType,
+                            typeDescription: FRAUD_TYPES[fraudType],
+                            severity,
+                            legalCitation,
+                            evidenceRefs: evidenceRecordIds,
+                            contentHash: record.contentHash,
+                        },
+                        suggestedCitations: Object.entries(LEGAL_CITATIONS)
+                            .filter(([key]) => key.includes('FTC') || key.includes('FRAUD') ||
+                            key.includes('PRIVACY') || key.includes('COMPUTER'))
+                            .map(([key, value]) => ({ code: key, citation: value })),
+                    });
+                },
+            },
+            // ─────────────────────────────────────────────────────────────────────────
+            // Cryptographic Hashing
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'CryptoHash',
+                description: `Compute cryptographic hashes for integrity verification.
+
+Algorithms: md5, sha1, sha256, sha384, sha512, sha3-256, sha3-512
+
+Operations:
+- hash: Compute hash of content
+- verify: Verify content against expected hash
+- file: Hash a file
+- compare: Compare two hashes`,
+                parameters: {
+                    type: 'object',
+                    required: ['operation'],
+                    properties: {
+                        operation: {
+                            type: 'string',
+                            enum: ['hash', 'verify', 'file', 'compare'],
+                            description: 'Operation to perform',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Content to hash (for hash/verify)',
+                        },
+                        filePath: {
+                            type: 'string',
+                            description: 'File path (for file operation)',
+                        },
+                        algorithm: {
+                            type: 'string',
+                            enum: ['md5', 'sha1', 'sha256', 'sha384', 'sha512', 'sha3-256', 'sha3-512'],
+                            description: 'Hash algorithm (default: sha256)',
+                        },
+                        expectedHash: {
+                            type: 'string',
+                            description: 'Expected hash value (for verify)',
+                        },
+                        hash1: {
+                            type: 'string',
+                            description: 'First hash (for compare)',
+                        },
+                        hash2: {
+                            type: 'string',
+                            description: 'Second hash (for compare)',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const operation = args['operation'];
+                    const content = args['content'];
+                    const filePath = args['filePath'];
+                    const algorithm = args['algorithm'] || 'sha256';
+                    const expectedHash = args['expectedHash'];
+                    const hash1 = args['hash1'];
+                    const hash2 = args['hash2'];
+                    switch (operation) {
+                        case 'hash': {
+                            if (!content) {
+                                return JSON.stringify({ success: false, error: 'Content required' });
+                            }
+                            const hash = hashString(content, algorithm);
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'hash',
+                                algorithm,
+                                hash,
+                                inputLength: content.length,
+                            });
+                        }
+                        case 'verify': {
+                            if (!content || !expectedHash) {
+                                return JSON.stringify({ success: false, error: 'Content and expectedHash required' });
+                            }
+                            const actualHash = hashString(content, algorithm);
+                            const match = actualHash === expectedHash.toLowerCase();
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'verify',
+                                algorithm,
+                                match,
+                                actualHash,
+                                expectedHash: expectedHash.toLowerCase(),
+                            });
+                        }
+                        case 'file': {
+                            if (!filePath) {
+                                return JSON.stringify({ success: false, error: 'filePath required' });
+                            }
+                            try {
+                                const hash = hashFile(filePath, algorithm);
+                                const stats = await fs.stat(filePath);
+                                return JSON.stringify({
+                                    success: true,
+                                    operation: 'file',
+                                    algorithm,
+                                    hash,
+                                    filePath,
+                                    fileSize: stats.size,
+                                    modified: stats.mtime.toISOString(),
+                                });
+                            }
+                            catch (error) {
+                                return JSON.stringify({
+                                    success: false,
+                                    error: `Failed to hash file: ${error instanceof Error ? error.message : String(error)}`,
+                                });
+                            }
+                        }
+                        case 'compare': {
+                            if (!hash1 || !hash2) {
+                                return JSON.stringify({ success: false, error: 'hash1 and hash2 required' });
+                            }
+                            const match = hash1.toLowerCase() === hash2.toLowerCase();
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'compare',
+                                match,
+                                hash1: hash1.toLowerCase(),
+                                hash2: hash2.toLowerCase(),
+                            });
+                        }
+                        default:
+                            return JSON.stringify({ success: false, error: `Unknown operation: ${operation}` });
+                    }
+                },
+            },
+            // ─────────────────────────────────────────────────────────────────────────
+            // Digital Signatures
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'CryptoSign',
+                description: `Digital signature operations for evidence authentication.
+
+Operations:
+- sign: Sign content with private key
+- verify: Verify signature with public key
+- generateKeys: Generate new RSA key pair
+- exportPublicKey: Export public key for verification`,
+                parameters: {
+                    type: 'object',
+                    required: ['operation'],
+                    properties: {
+                        operation: {
+                            type: 'string',
+                            enum: ['sign', 'verify', 'generateKeys', 'exportPublicKey'],
+                            description: 'Operation to perform',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Content to sign or verify',
+                        },
+                        signature: {
+                            type: 'string',
+                            description: 'Signature to verify',
+                        },
+                        publicKey: {
+                            type: 'string',
+                            description: 'Public key for verification (uses stored key if not provided)',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const operation = args['operation'];
+                    const content = args['content'];
+                    const signature = args['signature'];
+                    const publicKeyArg = args['publicKey'];
+                    const keys = await loadKeys();
+                    switch (operation) {
+                        case 'sign': {
+                            if (!content) {
+                                return JSON.stringify({ success: false, error: 'Content required' });
+                            }
+                            const privateKey = crypto.createPrivateKey(keys.privateKey);
+                            const sign = crypto.createSign('SHA256');
+                            sign.update(content);
+                            const sig = sign.sign(privateKey, 'hex');
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'sign',
+                                signature: sig,
+                                algorithm: 'SHA256withRSA',
+                                contentHash: hashString(content),
+                            });
+                        }
+                        case 'verify': {
+                            if (!content || !signature) {
+                                return JSON.stringify({ success: false, error: 'Content and signature required' });
+                            }
+                            const publicKey = crypto.createPublicKey(publicKeyArg || keys.publicKey);
+                            const verify = crypto.createVerify('SHA256');
+                            verify.update(content);
+                            const valid = verify.verify(publicKey, signature, 'hex');
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'verify',
+                                valid,
+                                algorithm: 'SHA256withRSA',
+                            });
+                        }
+                        case 'generateKeys': {
+                            const newKeys = IntegrityVerificationEngine.generateKeyPair();
+                            // Don't overwrite existing keys, just return new ones
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'generateKeys',
+                                publicKey: newKeys.publicKey,
+                                privateKey: '[GENERATED - store securely]',
+                                algorithm: 'RSA-4096',
+                                note: 'Keys generated but not stored. Use exportPublicKey to get stored public key.',
+                            });
+                        }
+                        case 'exportPublicKey': {
+                            return JSON.stringify({
+                                success: true,
+                                operation: 'exportPublicKey',
+                                publicKey: keys.publicKey,
+                                algorithm: 'RSA-4096',
+                            });
+                        }
+                        default:
+                            return JSON.stringify({ success: false, error: `Unknown operation: ${operation}` });
+                    }
+                },
+            },
+            // ─────────────────────────────────────────────────────────────────────────
+            // Tech Company Info
+            // ─────────────────────────────────────────────────────────────────────────
+            {
+                name: 'TechCompanyInfo',
+                description: `Get corporate and product information for major tech companies.
+
+Provides:
+- Legal entity names
+- Headquarters addresses
+- SEC filing information (CIK)
+- Product/service listings with data types collected
+- Registered agent information
+
+Useful for correctly naming defendants in legal filings.`,
+                parameters: {
+                    type: 'object',
+                    required: ['company'],
+                    properties: {
+                        company: {
+                            type: 'string',
+                            enum: ['apple', 'google', 'meta', 'microsoft', 'amazon', 'all'],
+                            description: 'Company to get info for',
+                        },
+                        includeProducts: {
+                            type: 'boolean',
+                            description: 'Include product details',
+                        },
+                    },
+                },
+                handler: async (args) => {
+                    const company = args['company'];
+                    const includeProducts = args['includeProducts'];
+                    if (company === 'all') {
+                        const summary = Object.entries(TECH_COMPANY_TARGETS).map(([key, info]) => ({
+                            id: key,
+                            company: info.company,
+                            legalName: info.corporateInfo.legalName,
+                            headquarters: info.corporateInfo.headquarters,
+                            productCount: info.products.length,
+                        }));
+                        return JSON.stringify({ success: true, companies: summary });
+                    }
+                    const info = TECH_COMPANY_TARGETS[company.toLowerCase()];
+                    if (!info) {
+                        return JSON.stringify({
+                            success: false,
+                            error: `Unknown company: ${company}`,
+                            available: Object.keys(TECH_COMPANY_TARGETS),
+                        });
+                    }
+                    const response = {
+                        success: true,
+                        company: info.company,
+                        corporateInfo: info.corporateInfo,
+                    };
+                    if (includeProducts) {
+                        response['products'] = info.products;
+                    }
+                    else {
+                        response['productCount'] = info.products.length;
+                        response['productNames'] = info.products.map(p => p.name);
+                    }
+                    return JSON.stringify(response);
+                },
+            },
+        ],
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELPER FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+async function fetchUrl(url) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? https : http;
+        const request = protocol.get(url, { timeout: 30000 }, (response) => {
+            if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                fetchUrl(response.headers.location).then(resolve).catch(reject);
+                return;
+            }
+            let data = '';
+            response.on('data', chunk => data += chunk);
+            response.on('end', () => resolve(data));
+            response.on('error', reject);
+        });
+        request.on('error', reject);
+        request.on('timeout', () => {
+            request.destroy();
+            reject(new Error('Request timeout'));
+        });
+    });
+}
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.txt': 'text/plain',
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        '.pdf': 'application/pdf',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.mp4': 'video/mp4',
+        '.webm': 'video/webm',
+        '.mp3': 'audio/mpeg',
+        '.wav': 'audio/wav',
+        '.zip': 'application/zip',
+        '.gz': 'application/gzip',
+        '.tar': 'application/x-tar',
+        '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.ppt': 'application/vnd.ms-powerpoint',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+function generateHtmlExhibit(exhibit) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Exhibit ${exhibit.exhibitNumber} - ${exhibit.title}</title>
+  <style>
+    body { font-family: 'Times New Roman', serif; max-width: 8.5in; margin: 0 auto; padding: 1in; }
+    h1 { text-align: center; border-bottom: 2px solid black; padding-bottom: 10px; }
+    h2 { border-bottom: 1px solid #666; padding-bottom: 5px; margin-top: 2em; }
+    .exhibit-header { text-align: center; margin-bottom: 2em; }
+    .exhibit-number { font-size: 1.5em; font-weight: bold; }
+    .metadata { background: #f5f5f5; padding: 15px; margin: 1em 0; border: 1px solid #ddd; }
+    .metadata dt { font-weight: bold; }
+    .metadata dd { margin-left: 20px; margin-bottom: 10px; }
+    .hash { font-family: monospace; background: #eee; padding: 2px 5px; word-break: break-all; }
+    .custody-table { width: 100%; border-collapse: collapse; margin: 1em 0; }
+    .custody-table th, .custody-table td { border: 1px solid #333; padding: 8px; text-align: left; }
+    .custody-table th { background: #f0f0f0; }
+    .proof-section { margin: 1em 0; padding: 10px; background: #f9f9f9; border-left: 3px solid #333; }
+    .certification { margin-top: 3em; border-top: 2px solid black; padding-top: 1em; }
+    .signature-line { margin-top: 3em; border-top: 1px solid black; width: 50%; }
+    @media print { body { padding: 0; } }
+  </style>
+</head>
+<body>
+  <div class="exhibit-header">
+    <div class="exhibit-number">EXHIBIT ${exhibit.exhibitNumber}</div>
+    <h1>${exhibit.title}</h1>
+    <p>${exhibit.description}</p>
+  </div>
+
+  <h2>Evidence Summary</h2>
+  <dl class="metadata">
+    <dt>Chain ID:</dt>
+    <dd class="hash">${exhibit.chainId}</dd>
+    <dt>Record Count:</dt>
+    <dd>${exhibit.recordIds.length}</dd>
+    <dt>Merkle Root Hash:</dt>
+    <dd class="hash">${exhibit.integrityProof.rootHash}</dd>
+    <dt>Hash Algorithm:</dt>
+    <dd>${exhibit.integrityProof.algorithm.toUpperCase()}</dd>
+    <dt>Generated:</dt>
+    <dd>${new Date(exhibit.generated).toLocaleString()}</dd>
+  </dl>
+
+  <h2>Chain of Custody</h2>
+  <table class="custody-table">
+    <thead>
+      <tr>
+        <th>Timestamp</th>
+        <th>Action</th>
+        <th>Actor</th>
+        <th>Description</th>
+        <th>Hash</th>
+      </tr>
+    </thead>
+    <tbody>
+      ${exhibit.chainOfCustody.map(entry => `
+        <tr>
+          <td>${new Date(entry.timestamp).toLocaleString()}</td>
+          <td>${entry.action.toUpperCase()}</td>
+          <td>${entry.actor}</td>
+          <td>${entry.description}</td>
+          <td class="hash">${entry.hash.slice(0, 16)}...</td>
+        </tr>
+      `).join('')}
+    </tbody>
+  </table>
+
+  <h2>Cryptographic Integrity Proofs</h2>
+  <div class="proof-section">
+    <p><strong>Merkle Tree Root:</strong> <span class="hash">${exhibit.integrityProof.rootHash}</span></p>
+    <p>This exhibit contains ${exhibit.integrityProof.merkleProofs.length} Merkle proofs that cryptographically verify the integrity and authenticity of each evidence record.</p>
+    <p><strong>Verification Method:</strong> Each record's content hash is a leaf in the Merkle tree. The sibling hashes at each level can be combined to reconstruct the root hash, proving the record has not been tampered with.</p>
+  </div>
+
+  ${exhibit.integrityProof.signatures.length > 0 ? `
+  <h2>Digital Signatures</h2>
+  <table class="custody-table">
+    <thead>
+      <tr>
+        <th>Signer</th>
+        <th>Timestamp</th>
+        <th>Algorithm</th>
+        <th>Signature (truncated)</th>
+      </tr>
+    </thead>
+    <tbody>
+      ${exhibit.integrityProof.signatures.map(sig => `
+        <tr>
+          <td>${sig.signer}</td>
+          <td>${new Date(sig.timestamp).toLocaleString()}</td>
+          <td>${sig.algorithm}</td>
+          <td class="hash">${sig.signature.slice(0, 32)}...</td>
+        </tr>
+      `).join('')}
+    </tbody>
+  </table>
+  ` : ''}
+
+  <div class="certification">
+    <h2>Certification</h2>
+    <p>I hereby certify under penalty of perjury that the evidence contained in this exhibit is true and accurate to the best of my knowledge, and that the cryptographic hashes and integrity proofs presented herein accurately represent the state of the evidence at the time of collection.</p>
+    <div class="signature-line">
+      <p>Signature: _______________________</p>
+      <p>Date: _______________________</p>
+      <p>Printed Name: _______________________</p>
+    </div>
+  </div>
+
+  <footer style="margin-top: 3em; text-align: center; color: #666; font-size: 0.9em;">
+    <p>Generated by erosolar-cli integrity verification system</p>
+    <p>Exhibit ID: ${exhibit.exhibitNumber} | Chain: ${exhibit.chainId.slice(0, 8)}...</p>
+  </footer>
+</body>
+</html>`;
+}
+//# sourceMappingURL=integrityTools.js.map