@mooncompany/uplink-chat 0.5.0

package/public/js/storage.js

@@ -0,0 +1,408 @@
+// ============================================
+// STORAGE MODULE
+// History persistence with encryption support
+// ============================================
+
+import { UplinkCore } from './core.js';
+import { UplinkEncryption } from './encryption.js';
+
+const HISTORY_KEY = 'uplink-history';
+const ENCRYPTED_KEY = 'uplink-history-encrypted';
+const SETTINGS_KEY = 'uplink-settings';
+const MAX_MESSAGES = 100;
+
+// Queue for serializing concurrent saveMessage calls
+let saveQueue = Promise.resolve();
+
+// Get core state
+function getCore() {
+  return UplinkCore.state || {};
+}
+
+// Get encryption module
+function getCrypto() {
+  return UplinkEncryption;
+}
+
+// Save a message to history (queued to prevent concurrent write races)
+async function saveMessage(msg) {
+  // Chain this save operation after any pending saves
+  saveQueue = saveQueue.then(async () => {
+    const core = getCore();
+    let history = await loadHistory();
+
+    // Don't store data URLs in history — they're too large for localStorage
+    // The server URL will replace it via updateLastImageUrl after upload completes
+    const safeMsg = { ...msg };
+    if (safeMsg.imageUrl && safeMsg.imageUrl.startsWith('data:')) {
+      safeMsg.imageUrl = '__pending_upload__';
+    }
+
+    history.push({
+      ...safeMsg,
+      timestamp: safeMsg.timestamp || Date.now()
+    });
+
+    // Limit history size
+    if (history.length > MAX_MESSAGES) {
+      history = history.slice(-MAX_MESSAGES);
+    }
+
+    await persistHistory(history);
+  }).catch(err => {
+    console.error('Storage: saveMessage error:', err);
+  });
+
+  return saveQueue;
+}
+
+// Load message history
+async function loadHistory() {
+  const core = getCore();
+  const cryptoMod = getCrypto();
+
+  try {
+    let history = null;
+    if (core.encryptionEnabled && core.currentPassword && cryptoMod) {
+      const encrypted = localStorage.getItem(ENCRYPTED_KEY);
+      if (encrypted) {
+        history = await cryptoMod.decrypt(JSON.parse(encrypted), core.currentPassword);
+      }
+    } else {
+      const plain = localStorage.getItem(HISTORY_KEY);
+      if (plain) {
+        history = JSON.parse(plain);
+      }
+    }
+
+    if (history) {
+      // Sanitize: strip any data URLs that may have leaked into storage
+      // These bloat localStorage and cause quota errors
+      let sanitized = false;
+      for (const msg of history) {
+        if (msg.imageUrl && msg.imageUrl.startsWith('data:')) {
+          msg.imageUrl = '__pending_upload__';
+          sanitized = true;
+        }
+      }
+      if (sanitized) {
+        // Persist the cleaned history to free up localStorage space
+        // Use try/catch so sanitization failure doesn't lose loaded history
+        try {
+          await persistHistory(history);
+        } catch (sanitizeError) {
+          console.warn('Storage: Failed to persist sanitized history, continuing with in-memory version', sanitizeError);
+        }
+      }
+      return history;
+    }
+  } catch (loadError) {
+    console.error('Storage: Failed to load history', loadError);
+  }
+  
+  return [];
+}
+
+// Persist history to storage
+async function persistHistory(history) {
+  const core = getCore();
+  const cryptoMod = getCrypto();
+
+  try {
+    if (core.encryptionEnabled && core.currentPassword && cryptoMod) {
+      const encrypted = await cryptoMod.encrypt(history, core.currentPassword);
+      localStorage.setItem(ENCRYPTED_KEY, JSON.stringify(encrypted));
+      localStorage.removeItem(HISTORY_KEY); // Remove plain version
+    } else {
+      localStorage.setItem(HISTORY_KEY, JSON.stringify(history));
+    }
+  } catch (persistError) {
+    console.error('Storage: Failed to persist history', persistError);
+    
+    // If quota exceeded, try to recover by stripping image URLs and retrying
+    if (persistError.name === 'QuotaExceededError' || persistError.code === 22) {
+      console.warn('Storage: Quota exceeded, stripping image URLs and retrying...');
+      for (const msg of history) {
+        if (msg.imageUrl && (msg.imageUrl.startsWith('data:') || msg.imageUrl === '__pending_upload__')) {
+          msg.imageUrl = null;
+        }
+      }
+      try {
+        localStorage.setItem(HISTORY_KEY, JSON.stringify(history));
+        console.log('Storage: Recovery successful after stripping image URLs');
+      } catch (retryError) {
+        console.error('Storage: Recovery failed, trimming history...', retryError);
+        // Last resort: keep only recent messages
+        const trimmed = history.slice(-50);
+        try {
+          localStorage.setItem(HISTORY_KEY, JSON.stringify(trimmed));
+          console.log('Storage: Recovery successful after trimming to 50 messages');
+        } catch (finalError) {
+          console.error('Storage: All recovery attempts failed', finalError);
+        }
+      }
+    }
+  }
+}
+
+// Clear history
+function clearHistory() {
+  localStorage.removeItem(HISTORY_KEY);
+  localStorage.removeItem(ENCRYPTED_KEY);
+}
+
+// Migrate history between encrypted/unencrypted
+async function migrateHistory(toEncrypted, newPassword) {
+  const history = await loadHistory();
+  const cryptoMod = getCrypto();
+
+  if (toEncrypted && newPassword && cryptoMod) {
+    const encrypted = await cryptoMod.encrypt(history, newPassword);
+    localStorage.setItem(ENCRYPTED_KEY, JSON.stringify(encrypted));
+    localStorage.removeItem(HISTORY_KEY);
+  } else {
+    localStorage.setItem(HISTORY_KEY, JSON.stringify(history));
+    localStorage.removeItem(ENCRYPTED_KEY);
+    if (cryptoMod) cryptoMod.clearEncryption();
+  }
+}
+
+// Save settings
+function saveSettings(settings) {
+  try {
+    const existing = loadSettings();
+    localStorage.setItem(SETTINGS_KEY, JSON.stringify({ ...existing, ...settings }));
+  } catch (saveError) {
+    console.error('Storage: Failed to save settings', saveError);
+  }
+}
+
+// Load settings
+function loadSettings() {
+  try {
+    return JSON.parse(localStorage.getItem(SETTINGS_KEY) || '{}');
+  } catch (parseError) {
+    return {};
+  }
+}
+
+// ===========================================
+// CROSS-DEVICE SYNC
+// ===========================================
+
+// Get auth headers for sync API calls
+function getAuthHeaders() {
+  const settings = JSON.parse(localStorage.getItem('uplink-settings') || '{}');
+  const token = settings.gatewayToken || '';
+  const headers = { 'Content-Type': 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+  return headers;
+}
+
+// Generate sync ID from password (deterministic hash)
+async function generateSyncId(password) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode('uplink-sync:' + password);
+  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('');
+}
+
+// Push encrypted history to server
+async function pushSync() {
+  const core = getCore();
+  const cryptoMod = getCrypto();
+  
+  if (!core.encryptionEnabled || !core.currentPassword) {
+    throw new Error('Encryption must be enabled for sync');
+  }
+  
+  const history = await loadHistory();
+  const satellites = localStorage.getItem('uplink-satellites');
+  
+  // Bundle all sync data
+  const syncData = {
+    history,
+    satellites: satellites ? JSON.parse(satellites) : null,
+    settings: loadSettings(),
+    syncedAt: Date.now()
+  };
+  
+  // Encrypt the bundle
+  const encrypted = await cryptoMod.encrypt(syncData, core.currentPassword);
+  const syncId = await generateSyncId(core.currentPassword);
+  
+  const res = await fetch('/api/sync/push', {
+    method: 'POST',
+    headers: getAuthHeaders(),
+    body: JSON.stringify({
+      syncId,
+      encryptedData: encrypted,
+      timestamp: Date.now()
+    })
+  });
+  
+  if (!res.ok) throw new Error('Sync push failed');
+  return await res.json();
+}
+
+// Pull encrypted history from server and decrypt
+async function pullSync() {
+  const core = getCore();
+  const cryptoMod = getCrypto();
+  
+  if (!core.encryptionEnabled || !core.currentPassword) {
+    throw new Error('Encryption must be enabled for sync');
+  }
+  
+  const syncId = await generateSyncId(core.currentPassword);
+  
+  const res = await fetch(`/api/sync/pull?syncId=${syncId}`, {
+    headers: getAuthHeaders(),
+  });
+  if (!res.ok) throw new Error('Sync pull failed');
+  
+  const data = await res.json();
+  if (!data.encryptedData) {
+    return null; // No sync data found
+  }
+  
+  // Decrypt the bundle
+  const syncData = await cryptoMod.decrypt(data.encryptedData, core.currentPassword);
+  
+  return syncData;
+}
+
+// Check if sync data exists
+async function checkSync() {
+  const core = getCore();
+  
+  if (!core.encryptionEnabled || !core.currentPassword) {
+    return { exists: false, reason: 'encryption_disabled' };
+  }
+  
+  const syncId = await generateSyncId(core.currentPassword);
+  
+  const res = await fetch(`/api/sync/check?syncId=${syncId}`, {
+    headers: getAuthHeaders(),
+  });
+  if (!res.ok) return { exists: false, reason: 'check_failed' };
+  
+  return await res.json();
+}
+
+// Apply sync data (merge or replace)
+async function applySync(syncData, mode = 'replace') {
+  if (!syncData) return;
+  
+  if (mode === 'replace') {
+    // Replace local data with synced data
+    if (syncData.history) {
+      await persistHistory(syncData.history);
+    }
+    if (syncData.satellites) {
+      localStorage.setItem('uplink-satellites', JSON.stringify(syncData.satellites));
+    }
+    if (syncData.settings) {
+      localStorage.setItem(SETTINGS_KEY, JSON.stringify(syncData.settings));
+    }
+  } else if (mode === 'merge') {
+    // Merge histories (dedupe by timestamp)
+    const local = await loadHistory();
+    const remote = syncData.history || [];
+    const merged = mergeHistories(local, remote);
+    await persistHistory(merged);
+    
+    // For satellites and settings, prefer remote if newer
+    if (syncData.satellites && syncData.syncedAt > (loadSettings().lastSyncedAt || 0)) {
+      localStorage.setItem('uplink-satellites', JSON.stringify(syncData.satellites));
+    }
+  }
+  
+  // Record last sync time
+  saveSettings({ lastSyncedAt: Date.now() });
+}
+
+// Merge two histories, deduping by timestamp
+function mergeHistories(local, remote) {
+  const seen = new Set();
+  const merged = [];
+  
+  [...local, ...remote]
+    .sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0))
+    .forEach(msg => {
+      const key = `${msg.timestamp}-${msg.type}-${(msg.text || '').substring(0, 50)}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged.push(msg);
+      }
+    });
+  
+  return merged.slice(-MAX_MESSAGES);
+}
+
+/**
+ * Update the last user image message's URL from data URL to server URL
+ * Prevents localStorage bloat from storing full base64 images
+ */
+async function updateLastImageUrl(serverUrl) {
+  saveQueue = saveQueue.then(async () => {
+    let history = await loadHistory();
+    
+    // Find last user message with a pending or data URL image
+    for (let i = history.length - 1; i >= 0; i--) {
+      const url = history[i].imageUrl;
+      if (history[i].type === 'user' && url && (url === '__pending_upload__' || url.startsWith('data:'))) {
+        history[i].imageUrl = serverUrl;
+        await persistHistory(history);
+        break;
+      }
+    }
+  }).catch(err => {
+    console.error('Storage: updateLastImageUrl error:', err);
+  });
+
+  return saveQueue;
+}
+
+// Export API
+export const UplinkStorage = {
+  saveMessage,
+  loadHistory,
+  clearHistory,
+  migrateHistory,
+  saveSettings,
+  loadSettings,
+  updateLastImageUrl,
+  // Sync functions
+  pushSync,
+  pullSync,
+  checkSync,
+  applySync,
+  generateSyncId,
+  MAX_MESSAGES
+};
+
+export {
+  saveMessage,
+  loadHistory,
+  clearHistory,
+  migrateHistory,
+  saveSettings,
+  loadSettings,
+  updateLastImageUrl,
+  pushSync,
+  pullSync,
+  checkSync,
+  applySync,
+  generateSyncId,
+  MAX_MESSAGES
+};
+
+// Backward compat: assign to window
+window.UplinkStorage = UplinkStorage;
+
+// Register with core
+UplinkCore.registerModule('storage');
+
+console.log('Storage: Loaded');