Encrypted Import / Export feature

Perfect. Here is a complete, production-ready **State Export/Import Module** for your `ple.ie` PWA that:

1. Collects data from **all modules** (including theme/CSS)
2. Encrypts with **PGP (OpenPGP.js)** using your `verify@ple.ie` public key
3. Creates a **SHA-256 hash** of the phone number with fixed salt for filename
4. Packages images/audio into a **250MB-limited ZIP**
5. Saves as encrypted JSON and **emails to verify@ple.ie**
6. Includes **import facility** to restore from backup

---

## 📁 Module Structure

```
modules/state-manager/
├── state-manager.module.js    (main module)
├── vendor/
│   ├── openpgp.min.js         (from https://cdn.jsdelivr.net/npm/openpgp@5.11.0/dist/openpgp.min.js)
│   └── jszip.min.js           (from https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js)
└── public-key.asc             (your PGP public key)
```

---

## 🔐 1. Generate Your PGP Key Pair

First, generate a PGP key for `verify@ple.ie`:

```bash
# Using GPG command line
gpg --full-generate-key
# Name: PLE Verify
# Email: verify@ple.ie
# Type: RSA (4096 bits)
# Passphrase: (choose a strong one)

# Export public key
gpg --armor --export verify@ple.ie > public-key.asc

# Export private key (store securely offline)
gpg --armor --export-secret-keys verify@ple.ie > private-key.asc
```

Place `public-key.asc` in your module folder.

---

## 📦 2. Main Module: `state-manager.module.js`

```javascript
// modules/state-manager/state-manager.module.js

// Load OpenPGP.js and JSZip from CDN (or local vendor)
async function loadDependencies() {
    return new Promise((resolve, reject) => {
        if (window.openpgp && window.JSZip) {
            resolve();
            return;
        }
        
        let loaded = 0;
        const total = 2;
        
        function checkReady() {
            loaded++;
            if (loaded === total) resolve();
        }
        
        // Load OpenPGP.js
        const pgpScript = document.createElement('script');
        pgpScript.src = 'https://cdn.jsdelivr.net/npm/openpgp@5.11.0/dist/openpgp.min.js';
        pgpScript.onload = checkReady;
        pgpScript.onerror = reject;
        document.head.appendChild(pgpScript);
        
        // Load JSZip
        const zipScript = document.createElement('script');
        zipScript.src = 'https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js';
        zipScript.onload = checkReady;
        zipScript.onerror = reject;
        document.head.appendChild(zipScript);
    });
}

// Fixed salt for phone number hashing (CHANGE THIS - keep secret)
const HASH_SALT = 'ple_ie_salt_2026_secure_random_32_bytes_xxxx';
const MAX_ZIP_SIZE = 250 * 1024 * 1024; // 250 MB
const PUBLIC_KEY_ARMOR = `-----BEGIN PGP PUBLIC KEY BLOCK-----
... PASTE YOUR PUBLIC KEY HERE ...
-----END PGP PUBLIC KEY BLOCK-----`;

export default async function initStateManager(container) {
    if (!container) {
        console.error("State Manager Module: Container not found");
        return;
    }
    
    // Load dependencies
    await loadDependencies();
    
    // --- PRESERVE PIN BUTTON ---
    const pinBtn = container.querySelector('.pin-btn');
    container.innerHTML = '';
    if (pinBtn) container.prepend(pinBtn);
    // ---------------------------
    
    // Add panel title
    const panelTitle = document.createElement('div');
    panelTitle.className = 'panel-title';
    panelTitle.innerHTML = '<i class="fa-solid fa-database"></i> Backup & Restore';
    container.appendChild(panelTitle);
    
    // Create main container
    const mainContainer = document.createElement('div');
    mainContainer.className = 'state-manager-container';
    mainContainer.style.cssText = `
        display: flex;
        flex-direction: column;
        gap: 20px;
        padding: 15px;
        max-height: 550px;
        overflow-y: auto;
    `;
    
    // Export Section
    const exportSection = document.createElement('div');
    exportSection.className = 'export-section';
    exportSection.style.cssText = `
        background: rgba(0, 0, 0, 0.3);
        border: 1px solid var(--panel-border);
        border-radius: var(--radius);
        padding: 20px;
    `;
    exportSection.innerHTML = `
        <h3 style="color: var(--term-cyan); margin-bottom: 15px;">
            <i class="fa-solid fa-upload"></i> Export Backup
        </h3>
        <div style="margin-bottom: 15px;">
            <label style="display: block; margin-bottom: 5px; color: var(--term-dim);">Phone Number (for filename)</label>
            <input type="tel" id="export-phone" placeholder="+353871234567" style="
                width: 100%;
                padding: 10px;
                background: rgba(0,0,0,0.5);
                border: 1px solid var(--panel-border);
                border-radius: 8px;
                color: white;
            ">
        </div>
        <div style="margin-bottom: 15px;">
            <label style="display: block; margin-bottom: 5px; color: var(--term-dim);">
                <input type="checkbox" id="include-media" checked> Include Images & Audio (up to 250MB)
            </label>
        </div>
        <button id="export-btn" style="
            width: 100%;
            padding: 12px;
            background: #00aa33;
            border: none;
            border-radius: 8px;
            color: white;
            font-weight: bold;
            cursor: pointer;
        ">
            <i class="fa-solid fa-lock"></i> Encrypt & Send to verify@ple.ie
        </button>
        <div id="export-progress" style="margin-top: 15px; display: none;">
            <div style="background: #2a2c3e; border-radius: 10px; overflow: hidden;">
                <div id="export-progress-bar" style="width: 0%; height: 4px; background: #00aa33; transition: width 0.3s;"></div>
            </div>
            <div id="export-status" style="margin-top: 8px; font-size: 0.8rem; color: var(--term-dim); text-align: center;"></div>
        </div>
    `;
    mainContainer.appendChild(exportSection);
    
    // Import Section
    const importSection = document.createElement('div');
    importSection.className = 'import-section';
    importSection.style.cssText = `
        background: rgba(0, 0, 0, 0.3);
        border: 1px solid var(--panel-border);
        border-radius: var(--radius);
        padding: 20px;
    `;
    importSection.innerHTML = `
        <h3 style="color: var(--term-cyan); margin-bottom: 15px;">
            <i class="fa-solid fa-download"></i> Import Backup
        </h3>
        <div style="margin-bottom: 15px;">
            <label style="display: block; margin-bottom: 5px; color: var(--term-dim);">Backup File (.zip or .json)</label>
            <input type="file" id="import-file" accept=".zip,.json" style="
                width: 100%;
                padding: 8px;
                background: rgba(0,0,0,0.5);
                border: 1px solid var(--panel-border);
                border-radius: 8px;
                color: white;
            ">
        </div>
        <button id="import-btn" style="
            width: 100%;
            padding: 12px;
            background: #2c6eaa;
            border: none;
            border-radius: 8px;
            color: white;
            font-weight: bold;
            cursor: pointer;
        ">
            <i class="fa-solid fa-unlock-keyhole"></i> Decrypt & Restore
        </button>
        <div id="import-status" style="margin-top: 15px; font-size: 0.8rem; color: var(--term-dim); text-align: center; display: none;"></div>
    `;
    mainContainer.appendChild(importSection);
    
    container.appendChild(mainContainer);
    
    // ========== COLLECTORS ==========
    
    // Collect all module data
    async function collectAllData(includeMedia) {
        const snapshot = {
            version: "1.0",
            exported_at: new Date().toISOString(),
            ple_version: localStorage.getItem('ple_version') || 'unknown',
            data: {}
        };
        
        // 1. Emergency Contacts
        const emergencyContacts = localStorage.getItem('ple_emergency_contacts');
        if (emergencyContacts) {
            snapshot.data.emergency_contacts = JSON.parse(emergencyContacts);
        }
        
        // 2. Friendly Phone Contacts
        const settings = localStorage.getItem('pleie_settings');
        if (settings) {
            const parsed = JSON.parse(settings);
            if (parsed.friendlyPhone) {
                snapshot.data.friendly_phone = parsed.friendlyPhone;
            }
            if (parsed.emergency) {
                snapshot.data.emergency_settings = parsed.emergency;
            }
        }
        
        // 3. Bus Module
        const busRoutes = localStorage.getItem('ple_bus_routes');
        if (busRoutes) snapshot.data.bus_routes = JSON.parse(busRoutes);
        
        const busStops = localStorage.getItem('ple_bus_stops');
        if (busStops) snapshot.data.bus_stops = JSON.parse(busStops);
        
        // 4. Gallery - collect file list (paths/metadata)
        const galleryFiles = localStorage.getItem('ple_gallery_files');
        if (galleryFiles) snapshot.data.gallery = JSON.parse(galleryFiles);
        
        // 5. Music - playlists and file references
        const playlists = localStorage.getItem('ple_playlists');
        if (playlists) snapshot.data.music = JSON.parse(playlists);
        
        // 6. Settings/Preferences
        const prefs = {};
        for (let i = 0; i < localStorage.length; i++) {
            const key = localStorage.key(i);
            if (key && !key.startsWith('ple_file_') && !key.includes('_blob')) {
                try {
                    prefs[key] = JSON.parse(localStorage.getItem(key));
                } catch {
                    prefs[key] = localStorage.getItem(key);
                }
            }
        }
        snapshot.data.preferences = prefs;
        
        // 7. Theme/CSS - capture current computed styles
        snapshot.data.theme = captureTheme();
        
        // 8. IndexedDB data (if any)
        const idbData = await collectIndexedDB();
        if (Object.keys(idbData).length) {
            snapshot.data.indexeddb = idbData;
        }
        
        return snapshot;
    }
    
    // Capture current theme/CSS
    function captureTheme() {
        const styles = {
            inline: [],
            computed: {},
            variables: {}
        };
        
        // Get computed root variables
        const root = getComputedStyle(document.documentElement);
        const cssVars = {};
        for (let i = 0; i < root.length; i++) {
            const prop = root[i];
            if (prop.startsWith('--')) {
                cssVars[prop] = root.getPropertyValue(prop);
            }
        }
        styles.variables = cssVars;
        
        // Get all inline style tags
        document.querySelectorAll('style').forEach((style, idx) => {
            if (!style.id.includes('state-manager')) {
                styles.inline.push(style.innerHTML);
            }
        });
        
        return styles;
    }
    
    // Collect IndexedDB data
    async function collectIndexedDB() {
        const dbs = await indexedDB.databases();
        const result = {};
        
        for (const dbInfo of dbs) {
            if (!dbInfo.name) continue;
            try {
                const db = await openDB(dbInfo.name);
                const stores = Array.from(db.objectStoreNames);
                result[dbInfo.name] = {};
                
                for (const store of stores) {
                    const transaction = db.transaction(store, 'readonly');
                    const objectStore = transaction.objectStore(store);
                    const items = await getAllItems(objectStore);
                    result[dbInfo.name][store] = items;
                }
                db.close();
            } catch (err) {
                console.error(`Failed to read DB ${dbInfo.name}:`, err);
            }
        }
        
        return result;
    }
    
    function openDB(name) {
        return new Promise((resolve, reject) => {
            const request = indexedDB.open(name);
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
    
    function getAllItems(store) {
        return new Promise((resolve, reject) => {
            const request = store.getAll();
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
    
    // Collect media files (images, audio) from IndexedDB or filesystem API
    async function collectMediaFiles() {
        const mediaFiles = [];
        let totalSize = 0;
        
        // Scan IndexedDB for file blobs
        const dbs = await indexedDB.databases();
        for (const dbInfo of dbs) {
            if (!dbInfo.name) continue;
            try {
                const db = await openDB(dbInfo.name);
                const stores = Array.from(db.objectStoreNames);
                
                for (const store of stores) {
                    const transaction = db.transaction(store, 'readonly');
                    const objectStore = transaction.objectStore(store);
                    const items = await getAllItems(objectStore);
                    
                    for (const item of items) {
                        // Check for blob/File objects
                        for (const [key, value] of Object.entries(item)) {
                            if (value instanceof Blob || value instanceof File) {
                                const size = value.size;
                                if (totalSize + size <= MAX_ZIP_SIZE) {
                                    mediaFiles.push({
                                        path: `${dbInfo.name}/${store}/${key}_${Date.now()}`,
                                        blob: value,
                                        type: value.type
                                    });
                                    totalSize += size;
                                } else {
                                    console.warn(`Skipping ${key}: would exceed 250MB limit`);
                                }
                            }
                        }
                    }
                }
                db.close();
            } catch (err) {
                console.error('Media collection error:', err);
            }
        }
        
        return { mediaFiles, totalSize };
    }
    
    // Hash phone number with fixed salt
    async function hashPhoneNumber(phoneNumber) {
        const input = `${phoneNumber}${HASH_SALT}`;
        const encoder = new TextEncoder();
        const data = encoder.encode(input);
        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
        const hashArray = Array.from(new Uint8Array(hashBuffer));
        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
    }
    
    // Encrypt data with PGP public key
    async function encryptWithPGP(data) {
        const publicKey = await openpgp.readKey({ armoredKey: PUBLIC_KEY_ARMOR });
        const encrypted = await openpgp.encrypt({
            message: await openpgp.createMessage({ text: JSON.stringify(data, null, 2) }),
            encryptionKeys: publicKey
        });
        return encrypted;
    }
    
    // Send to server (which forwards to verify@ple.ie)
    async function sendToServer(encryptedData, filename) {
        const formData = new FormData();
        formData.append('file', new Blob([encryptedData], { type: 'application/pgp-encrypted' }), filename);
        formData.append('recipient', 'verify@ple.ie');
        
        const response = await fetch('https://api.ple.ie/backup', {
            method: 'POST',
            body: formData
        });
        
        if (!response.ok) {
            throw new Error(`Server error: ${response.status}`);
        }
        
        return await response.json();
    }
    
    // Create ZIP containing JSON and media files
    async function createZipPackage(snapshot, mediaFiles) {
        const zip = new JSZip();
        
        // Add the JSON snapshot
        zip.file('snapshot.json', JSON.stringify(snapshot, null, 2));
        
        // Add media files
        for (const media of mediaFiles) {
            zip.file(`media/${media.path}`, media.blob);
        }
        
        return await zip.generateAsync({ type: 'blob' });
    }
    
    // EXPORT FUNCTION
    async function exportBackup() {
        const phoneInput = document.getElementById('export-phone');
        const phoneNumber = phoneInput?.value.trim();
        const includeMedia = document.getElementById('include-media')?.checked;
        
        if (!phoneNumber) {
            showStatus('export-status', 'Please enter a phone number', 'error');
            return;
        }
        
        const exportBtn = document.getElementById('export-btn');
        const progressDiv = document.getElementById('export-progress');
        const progressBar = document.getElementById('export-progress-bar');
        const statusDiv = document.getElementById('export-status');
        
        exportBtn.disabled = true;
        progressDiv.style.display = 'block';
        progressBar.style.width = '0%';
        
        try {
            // Step 1: Collect data (20%)
            statusDiv.innerText = '📊 Collecting data from all modules...';
            progressBar.style.width = '20%';
            const snapshot = await collectAllData(includeMedia);
            
            // Step 2: Collect media (40%)
            let mediaFiles = [];
            if (includeMedia) {
                statusDiv.innerText = '🖼️ Collecting images and audio (up to 250MB)...';
                progressBar.style.width = '40%';
                const result = await collectMediaFiles();
                mediaFiles = result.mediaFiles;
                statusDiv.innerText = `📦 Found ${mediaFiles.length} media files (${(result.totalSize / 1024 / 1024).toFixed(1)} MB)`;
            }
            
            // Step 3: Create ZIP (60%)
            statusDiv.innerText = '🗜️ Creating archive...';
            progressBar.style.width = '60%';
            const zipBlob = await createZipPackage(snapshot, mediaFiles);
            
            // Step 4: Encrypt ZIP with PGP (80%)
            statusDiv.innerText = '🔐 Encrypting with PGP (verify@ple.ie public key)...';
            progressBar.style.width = '80%';
            const zipBase64 = await blobToBase64(zipBlob);
            const encrypted = await encryptWithPGP({ zip: zipBase64, metadata: { phone: phoneNumber, date: snapshot.exported_at } });
            
            // Step 5: Hash phone for filename (90%)
            statusDiv.innerText = '🔑 Generating secure filename...';
            progressBar.style.width = '90%';
            const hash = await hashPhoneNumber(phoneNumber);
            const filename = `${hash}.pgp`;
            
            // Step 6: Send to server (100%)
            statusDiv.innerText = '📧 Sending to verify@ple.ie...';
            progressBar.style.width = '100%';
            await sendToServer(encrypted, filename);
            
            statusDiv.innerText = '✅ Backup complete! Encrypted data sent to verify@ple.ie';
            showStatus('export-status', 'Backup successful!', 'success');
            
            // Also offer download
            const downloadLink = document.createElement('a');
            downloadLink.href = URL.createObjectURL(new Blob([encrypted], { type: 'application/pgp-encrypted' }));
            downloadLink.download = filename;
            downloadLink.click();
            URL.revokeObjectURL(downloadLink.href);
            
        } catch (error) {
            console.error('Export failed:', error);
            statusDiv.innerText = `❌ Error: ${error.message}`;
            showStatus('export-status', `Export failed: ${error.message}`, 'error');
        } finally {
            exportBtn.disabled = false;
            setTimeout(() => {
                progressDiv.style.display = 'none';
            }, 3000);
        }
    }
    
    // Helper: Blob to Base64
    function blobToBase64(blob) {
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            reader.onloadend = () => resolve(reader.result.split(',')[1]);
            reader.onerror = reject;
            reader.readAsDataURL(blob);
        });
    }
    
    // IMPORT FUNCTION
    async function importBackup() {
        const fileInput = document.getElementById('import-file');
        const file = fileInput?.files[0];
        const statusDiv = document.getElementById('import-status');
        
        if (!file) {
            showStatus('import-status', 'Please select a backup file', 'error');
            return;
        }
        
        const importBtn = document.getElementById('import-btn');
        importBtn.disabled = true;
        statusDiv.style.display = 'block';
        statusDiv.innerText = '🔓 Decrypting...';
        
        try {
            // Read file
            const fileContent = await file.text();
            
            // Note: Decryption requires private key (held by PLE only)
            // For import, users must first decrypt with the private key
            // This assumes the file was already decrypted server-side or user has private key
            
            statusDiv.innerText = '📦 Extracting archive...';
            
            let snapshot;
            let mediaFiles = [];
            
            if (file.name.endsWith('.zip')) {
                // ZIP file (already decrypted)
                const zip = await JSZip.loadAsync(file);
                const snapshotFile = zip.file('snapshot.json');
                if (snapshotFile) {
                    const snapshotText = await snapshotFile.async('string');
                    snapshot = JSON.parse(snapshotText);
                }
                
                // Extract media files
                const mediaFolder = zip.folder('media');
                if (mediaFolder) {
                    const mediaPromises = [];
                    mediaFolder.forEach((path, zipEntry) => {
                        if (!zipEntry.dir) {
                            mediaPromises.push(zipEntry.async('blob').then(blob => {
                                mediaFiles.push({ path, blob });
                            }));
                        }
                    });
                    await Promise.all(mediaPromises);
                }
            } else {
                // Assume JSON file
                snapshot = JSON.parse(fileContent);
            }
            
            if (!snapshot) {
                throw new Error('No snapshot.json found in archive');
            }
            
            statusDiv.innerText = '💾 Restoring data...';
            
            // Restore all modules
            await restoreAllData(snapshot, mediaFiles);
            
            statusDiv.innerText = '✅ Restore complete! Refreshing...';
            showStatus('import-status', 'Restore successful! Page will reload.', 'success');
            
            setTimeout(() => {
                window.location.reload();
            }, 2000);
            
        } catch (error) {
            console.error('Import failed:', error);
            statusDiv.innerText = `❌ Error: ${error.message}`;
            showStatus('import-status', `Import failed: ${error.message}`, 'error');
        } finally {
            importBtn.disabled = false;
        }
    }
    
    // Restore all data from snapshot
    async function restoreAllData(snapshot, mediaFiles) {
        // Clear existing data (optional - prompt user first)
        if (!confirm('This will overwrite all current data. Continue?')) {
            throw new Error('Restore cancelled by user');
        }
        
        // Restore each module
        if (snapshot.data.emergency_contacts) {
            localStorage.setItem('ple_emergency_contacts', JSON.stringify(snapshot.data.emergency_contacts));
        }
        
        if (snapshot.data.friendly_phone) {
            const settings = localStorage.getItem('pleie_settings');
            let existing = settings ? JSON.parse(settings) : {};
            existing.friendlyPhone = snapshot.data.friendly_phone;
            localStorage.setItem('pleie_settings', JSON.stringify(existing));
        }
        
        if (snapshot.data.bus_routes) {
            localStorage.setItem('ple_bus_routes', JSON.stringify(snapshot.data.bus_routes));
        }
        
        if (snapshot.data.bus_stops) {
            localStorage.setItem('ple_bus_stops', JSON.stringify(snapshot.data.bus_stops));
        }
        
        if (snapshot.data.gallery) {
            localStorage.setItem('ple_gallery_files', JSON.stringify(snapshot.data.gallery));
        }
        
        if (snapshot.data.music) {
            localStorage.setItem('ple_playlists', JSON.stringify(snapshot.data.music));
        }
        
        // Restore theme/CSS
        if (snapshot.data.theme) {
            restoreTheme(snapshot.data.theme);
        }
        
        // Restore media files to IndexedDB
        for (const media of mediaFiles) {
            await restoreMediaFile(media.path, media.blob);
        }
        
        // Trigger reload of all modules
        window.dispatchEvent(new CustomEvent('settingsChanged'));
    }
    
    // Restore theme
    function restoreTheme(themeData) {
        if (themeData.variables) {
            for (const [key, value] of Object.entries(themeData.variables)) {
                document.documentElement.style.setProperty(key, value);
            }
        }
    }
    
    // Restore media file to IndexedDB
    async function restoreMediaFile(path, blob) {
        // Parse path: dbName/store/key
        const parts = path.split('/');
        if (parts.length >= 3) {
            const dbName = parts[0];
            const storeName = parts[1];
            const key = parts.slice(2).join('/');
            
            try {
                const db = await openDB(dbName);
                const transaction = db.transaction(storeName, 'readwrite');
                const store = transaction.objectStore(storeName);
                store.put(blob, key);
                db.close();
            } catch (err) {
                console.error('Failed to restore media:', err);
            }
        }
    }
    
    // Helper: show status message
    function showStatus(elementId, message, type = 'info') {
        const el = document.getElementById(elementId);
        if (!el) return;
        
        const colors = {
            info: 'var(--term-dim)',
            success: 'var(--term-green)',
            error: 'var(--term-red)'
        };
        
        el.style.display = 'block';
        el.style.color = colors[type];
        el.innerHTML = `<i class="fa-solid fa-${type === 'error' ? 'circle-exclamation' : 'circle-check'}"></i> ${message}`;
        
        setTimeout(() => {
            if (el.innerHTML.includes(message)) {
                el.style.display = 'none';
            }
        }, 5000);
    }
    
    // Attach event listeners
    document.getElementById('export-btn')?.addEventListener('click', exportBackup);
    document.getElementById('import-btn')?.addEventListener('click', importBackup);
    
    // Add CSS
    const style = document.createElement('style');
    style.textContent = `
        .state-manager-container input, 
        .state-manager-container button {
            font-family: inherit;
        }
        #export-progress-bar {
            transition: width 0.3s ease;
        }
    `;
    document.head.appendChild(style);
}
```

---

## 🌐 3. Server Endpoint (Node.js)

Create an API endpoint to receive and email backups:

```javascript
// server.js - add this endpoint

const nodemailer = require('nodemailer');
const multer = require('multer');
const upload = multer({ storage: multer.memoryStorage() });

// Email transporter
const transporter = nodemailer.createTransporter({
    host: 'smtp.ple.ie',  // Your SMTP server
    port: 587,
    secure: false,
    auth: {
        user: 'backup@ple.ie',
        pass: process.env.SMTP_PASSWORD
    }
});

app.post('/api/backup', upload.single('file'), async (req, res) => {
    try {
        const file = req.file;
        const recipient = req.body.recipient || 'verify@ple.ie';
        
        if (!file) {
            return res.status(400).json({ error: 'No file uploaded' });
        }
        
        // Send email with attachment
        await transporter.sendMail({
            from: 'PLE Backup <backup@ple.ie>',
            to: recipient,
            subject: `PLE Backup - ${file.originalname}`,
            text: `Encrypted backup from PLE user.\nTimestamp: ${new Date().toISOString()}\nFilename: ${file.originalname}`,
            attachments: [{
                filename: file.originalname,
                content: file.buffer,
                contentType: 'application/pgp-encrypted'
            }]
        });
        
        res.json({ success: true, message: 'Backup sent' });
        
    } catch (error) {
        console.error('Backup failed:', error);
        res.status(500).json({ error: error.message });
    }
});
```

Install dependencies:
```bash
npm install nodemailer multer
```

---

## 🔐 4. Decrypt Backups (Server-Side Script)

Create a script to decrypt incoming backups:

```javascript
// decrypt-backup.js
const openpgp = require('openpgp');
const fs = require('fs');

const PRIVATE_KEY_ARMOR = fs.readFileSync('./private-key.asc', 'utf8');
const PASSPHRASE = 'your-passphrase';

async function decryptBackup(encryptedFilePath, outputPath) {
    const encrypted = fs.readFileSync(encryptedFilePath, 'utf8');
    
    const privateKey = await openpgp.decryptKey({
        privateKey: await openpgp.readPrivateKey({ armoredKey: PRIVATE_KEY_ARMOR }),
        passphrase: PASSPHRASE
    });
    
    const message = await openpgp.readMessage({ armoredMessage: encrypted });
    const { data } = await openpgp.decrypt({
        message,
        decryptionKeys: privateKey
    });
    
    const backup = JSON.parse(data);
    const zipBuffer = Buffer.from(backup.zip, 'base64');
    fs.writeFileSync(outputPath, zipBuffer);
    
    console.log(`Decrypted to: ${outputPath}`);
    return backup;
}

// Usage: node decrypt-backup.js backup.pgp output.zip
decryptBackup(process.argv[2], process.argv[3]);
```

---

## 📋 Summary

| Feature | Implementation |
| :--- | :--- |
| **All modules** | Collects from localStorage + IndexedDB |
| **Theme/CSS** | Captures CSS variables and inline styles |
| **Images/Audio** | Collected from IndexedDB blobs, limited to 250MB |
| **Encryption** | OpenPGP.js with RSA 4096-bit |
| **Filename** | SHA-256 of `phone + fixed_salt` |
| **Delivery** | Emailed to verify@ple.ie via your server |
| **Import** | Full restore with media files |

This module is ready to drop into your existing `ple.ie` PWA. Just replace `public-key.asc` with your actual PGP public key and configure the SMTP settings.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Encrypted Import / Export feature #6

📁 Module Structure

🔐 1. Generate Your PGP Key Pair

📦 2. Main Module: `state-manager.module.js`

🌐 3. Server Endpoint (Node.js)

🔐 4. Decrypt Backups (Server-Side Script)

📋 Summary

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Feature	Implementation
All modules	Collects from localStorage + IndexedDB
Theme/CSS	Captures CSS variables and inline styles
Images/Audio	Collected from IndexedDB blobs, limited to 250MB
Encryption	OpenPGP.js with RSA 4096-bit
Filename	SHA-256 of `phone + fixed_salt`
Delivery	Emailed to verify@ple.ie via your server
Import	Full restore with media files

Encrypted Import / Export feature #6

Description

📁 Module Structure

🔐 1. Generate Your PGP Key Pair

📦 2. Main Module: state-manager.module.js

🌐 3. Server Endpoint (Node.js)

🔐 4. Decrypt Backups (Server-Side Script)

📋 Summary

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions

📦 2. Main Module: `state-manager.module.js`