Connection Lost
SecureBit.chat is now in offline mode. Some features are limited, but your data is safe.
Your session and keys are preserved
No data is stored on servers
Messages will sync when online
`;
document.body.appendChild(guidance);
// Save that we showed the guidance
localStorage.setItem('offline_guidance_shown', Date.now().toString());
// Auto-remove after 15 seconds
setTimeout(() => {
if (guidance.parentElement) {
guidance.remove();
}
}, 15000);
}
startReconnectionAttempts() {
if (this.reconnectInterval) {
clearInterval(this.reconnectInterval);
}
this.reconnectInterval = setInterval(() => {
if (this.isOnline) {
clearInterval(this.reconnectInterval);
this.reconnectInterval = null;
return;
}
this.reconnectAttempts++;
// Try to detect if we're actually back online
this.checkOnlineStatus();
if (this.reconnectAttempts >= this.maxReconnectAttempts) {
clearInterval(this.reconnectInterval);
this.reconnectInterval = null;
}
}, 10000); // Try every 10 seconds
}
async checkOnlineStatus() {
try {
// Try to fetch a small resource to check connectivity
const response = await fetch('/favicon.ico', {
method: 'HEAD',
cache: 'no-cache',
signal: AbortSignal.timeout(5000)
});
if (response.ok && !this.isOnline) {
this.isOnline = true;
this.handleConnectionRestored();
}
} catch (error) {
// Still offline
console.log('๐ด Still offline');
}
}
async queueOfflineAction(action) {
if (!this.offlineDB) {
console.warn('โ ๏ธ Offline database not available');
this.offlineQueue.push(action);
return;
}
const queueItem = {
...action,
id: Date.now() + Math.random(),
timestamp: Date.now(),
priority: action.priority || 1,
retryCount: 0,
maxRetries: action.maxRetries || 3
};
try {
const transaction = this.offlineDB.transaction(['offlineQueue'], 'readwrite');
const store = transaction.objectStore('offlineQueue');
await this.promisifyRequest(store.add(queueItem));
this.offlineQueue.push(queueItem);
// Try to register background sync
if (this.registration) {
await this.registration.sync.register('offline-sync');
}
} catch (error) {
console.error('โ Failed to queue offline action:', error);
// Fallback to memory queue
this.offlineQueue.push(queueItem);
}
}
async processOfflineQueue() {
if (this.syncInProgress || !this.isOnline) {
return;
}
this.syncInProgress = true;
let processedCount = 0;
let errorCount = 0;
try {
// Process database queue
if (this.offlineDB) {
const transaction = this.offlineDB.transaction(['offlineQueue'], 'readwrite');
const store = transaction.objectStore('offlineQueue');
const allItems = await this.promisifyRequest(store.getAll());
// Sort by priority and timestamp
allItems.sort((a, b) => {
if (a.priority !== b.priority) {
return b.priority - a.priority; // Higher priority first
}
return a.timestamp - b.timestamp; // Older first
});
for (const item of allItems) {
try {
await this.processQueueItem(item);
await this.promisifyRequest(store.delete(item.id));
processedCount++;
} catch (error) {
console.error('โ Failed to process offline action:', error);
errorCount++;
// Increment retry count
item.retryCount = (item.retryCount || 0) + 1;
if (item.retryCount >= item.maxRetries) {
// Max retries reached, remove from queue
await this.promisifyRequest(store.delete(item.id));
console.log('โ Max retries reached for action:', item.type);
} else {
// Update retry count in database
await this.promisifyRequest(store.put(item));
}
}
}
}
// Process in-memory queue as fallback
const memoryQueue = [...this.offlineQueue];
this.offlineQueue = [];
for (const item of memoryQueue) {
try {
await this.processQueueItem(item);
processedCount++;
} catch (error) {
console.error('โ Failed to process memory queue item:', error);
errorCount++;
item.retryCount = (item.retryCount || 0) + 1;
if (item.retryCount < item.maxRetries) {
this.offlineQueue.push(item); // Re-queue for retry
}
}
}
this.lastSyncTime = Date.now();
if (processedCount > 0 || errorCount > 0) {
this.showSyncNotification(processedCount, errorCount);
}
} catch (error) {
console.error('โ Error processing offline queue:', error);
} finally {
this.syncInProgress = false;
}
}
async processQueueItem(item) {
switch (item.type) {
case 'message':
return this.retryMessage(item.data);
case 'connection':
return this.retryConnection(item.data);
case 'payment_check':
return this.retryPaymentCheck(item.data);
case 'session_verification':
return this.retrySessionVerification(item.data);
case 'key_exchange':
return this.retryKeyExchange(item.data);
default:
console.warn('Unknown queue item type:', item.type);
throw new Error(`Unknown queue item type: ${item.type}`);
}
}
async retryMessage(messageData) {
// Retry sending message when back online
if (window.webrtcManager && window.webrtcManager.isConnected()) {
return window.webrtcManager.sendMessage(messageData.content);
}
throw new Error('WebRTC not connected');
}
async retryConnection(connectionData) {
// Retry connection establishment
if (window.webrtcManager) {
return window.webrtcManager.retryConnection();
}
throw new Error('WebRTC manager not available');
}
async retryPaymentCheck(paymentData) {
// Retry payment verification
if (window.sessionManager) {
return window.sessionManager.checkPaymentStatus(paymentData.checkingId);
}
throw new Error('Session manager not available');
}
async retrySessionVerification(sessionData) {
// Retry session verification
if (window.sessionManager) {
return window.sessionManager.verifyPayment(sessionData.preimage, sessionData.paymentHash);
}
throw new Error('Session manager not available');
}
async retryKeyExchange(keyData) {
// Retry key exchange
if (window.webrtcManager) {
return window.webrtcManager.handleKeyExchange(keyData);
}
throw new Error('WebRTC manager not available');
}
showSyncNotification(successCount, errorCount) {
const notification = document.createElement('div');
notification.className = 'fixed bottom-4 right-4 bg-green-500 text-white p-4 rounded-lg shadow-lg z-50 max-w-sm transform translate-x-full transition-transform duration-300';
let message = '';
if (successCount > 0 && errorCount === 0) {
message = `โ
Synced ${successCount} offline action${successCount > 1 ? 's' : ''}`;
} else if (successCount > 0 && errorCount > 0) {
message = `โ ๏ธ Synced ${successCount}, ${errorCount} failed`;
} else if (errorCount > 0) {
message = `โ ${errorCount} sync error${errorCount > 1 ? 's' : ''}`;
}
notification.innerHTML = `