diff --git a/src/background/alarms.ts b/src/background/alarms.ts new file mode 100644 index 0000000..dfc010b --- /dev/null +++ b/src/background/alarms.ts @@ -0,0 +1,41 @@ +import { browser } from '@/shared/browser' +import { ALARM_NAMES, SUSPENSION_CHECK_INTERVAL_MINUTES, RECOVERY_CONFIG } from '@/shared/constants' + +export async function setupSuspensionAlarm(): Promise { + await browser.alarms.clear(ALARM_NAMES.SUSPENSION_CHECK) + await browser.alarms.create(ALARM_NAMES.SUSPENSION_CHECK, { + periodInMinutes: SUSPENSION_CHECK_INTERVAL_MINUTES, + }) +} + +export async function setupAutoSaveAlarm(intervalMinutes: number): Promise { + await browser.alarms.clear(ALARM_NAMES.AUTO_SAVE) + await browser.alarms.create(ALARM_NAMES.AUTO_SAVE, { + periodInMinutes: intervalMinutes, + }) +} + +export async function setupCloudSyncAlarm(intervalMinutes: number): Promise { + await browser.alarms.clear(ALARM_NAMES.CLOUD_SYNC) + await browser.alarms.create(ALARM_NAMES.CLOUD_SYNC, { + periodInMinutes: intervalMinutes, + }) +} + +export async function setupRecoverySnapshotAlarm(): Promise { + await browser.alarms.clear(ALARM_NAMES.RECOVERY_SNAPSHOT) + await browser.alarms.create(ALARM_NAMES.RECOVERY_SNAPSHOT, { + periodInMinutes: RECOVERY_CONFIG.INTERVAL_MINUTES, + }) +} + +/** + * Daily check to decide whether an export reminder is due. + */ +export async function setupExportReminderAlarm(): Promise { + await browser.alarms.clear(ALARM_NAMES.EXPORT_REMINDER) + await browser.alarms.create(ALARM_NAMES.EXPORT_REMINDER, { + periodInMinutes: 60 * 24, + delayInMinutes: 60, + }) +} diff --git a/src/background/badge.ts b/src/background/badge.ts new file mode 100644 index 0000000..2698ca3 --- /dev/null +++ b/src/background/badge.ts @@ -0,0 +1,21 @@ +import { browser } from '@/shared/browser' +import { settingsStorage } from '@/shared/storage' +import { getTabCounts } from './suspension' + +/** + * Update the extension badge with suspended tab count. + */ +export async function updateBadge(): Promise { + const settings = await settingsStorage.get() + + if (!settings.ui.showBadge) { + await browser.action.setBadgeText({ text: '' }) + return + } + + const counts = await getTabCounts() + const text = counts.suspended > 0 ? counts.suspended.toString() : '' + + await browser.action.setBadgeText({ text }) + await browser.action.setBadgeBackgroundColor({ color: '#c07a42' }) // raft-500 +} diff --git a/src/background/contextMenus.ts b/src/background/contextMenus.ts new file mode 100644 index 0000000..0e2a510 --- /dev/null +++ b/src/background/contextMenus.ts @@ -0,0 +1,45 @@ +import { browser } from '@/shared/browser' + +/** + * Set up context menus for right-click actions. + */ +export async function setupContextMenus(): Promise { + await browser.contextMenus.removeAll() + + try { + browser.contextMenus.create( + { + id: 'suspend-tab', + title: 'Suspend this tab', + contexts: ['page'], + }, + () => { + if (browser.runtime.lastError) { + console.warn('[Raft] Failed to create suspend-tab menu:', browser.runtime.lastError) + } + } + ) + } catch (err) { + console.warn('[Raft] Failed to create suspend-tab menu:', err) + } + + try { + browser.contextMenus.create( + { + id: 'suspend-other-tabs', + title: 'Suspend other tabs in window', + contexts: ['page'], + }, + () => { + if (browser.runtime.lastError) { + console.warn( + '[Raft] Failed to create suspend-other-tabs menu:', + browser.runtime.lastError + ) + } + } + ) + } catch (err) { + console.warn('[Raft] Failed to create suspend-other-tabs menu:', err) + } +} diff --git a/src/background/index.ts b/src/background/index.ts index 43c9ea5..3305857 100644 --- a/src/background/index.ts +++ b/src/background/index.ts @@ -6,298 +6,52 @@ * - No persistent in-memory state * - Everything must be stored in browser.storage * - Re-register alarms and listeners on every wake + * + * Listener registration MUST stay synchronous at the top of this module so + * that wake-up events fired during the cold-start gap are caught. Listener + * BODIES (in ./listeners) await initReady before touching state that + * initialize() populates from storage. */ import { browser } from '@/shared/browser' -import { settingsStorage, tabActivityStorage, sessionsStorage, storage } from '@/shared/storage' -import { - ALARM_NAMES, - SUSPENSION_CHECK_INTERVAL_MINUTES, - STORAGE_KEYS, - CLOUD_SYNC_KEYS, - DEV_TEST_WINDOWS_KEY, - RECOVERY_CONFIG, - EXPORT_REMINDER_CONFIG, - SESSION_KEYS, - HIBERNATION_GUARD_DURATION_MS, - PROTECTED_URL_PATTERNS, -} from '@/shared/constants' -import { - shouldRestoreFromSync, - restoreFromSync, - backupSession, - getSyncStatus, - clearSyncData, -} from '@/shared/syncBackup' -import { - syncEngine, - gdrive, - cloudSyncSettingsStorage, - cloudCredentialsStorage, - encryptionKeyStorage, - syncStateStorage, - clearAllCloudSyncData, - launchGoogleOAuth, - setupEncryption, - encryptObject, - decryptObject, - revokeAccess, - deriveKey, - deriveKeyFromRecovery, - generateRecoveryKey, - generateSalt, - createVerificationHash, -} from '@/shared/cloudSync' -import type { CloudTokens, EncryptedPayload } from '@/shared/cloudSync' +import { settingsStorage, tabActivityStorage } from '@/shared/storage' +import { syncEngine, cloudSyncSettingsStorage } from '@/shared/cloudSync' import { - checkLicense, - openCheckoutPage, - canUseCloudSync, - activateLicense, - getStoredLicense, - clearLicense, - isProUser, -} from '@/shared/licensing' + initReady, + markInitReady, + loadPreviousActiveTabs, + savePreviousActiveTabs, + previousActiveTab, +} from './state' +import { updateBadge } from './badge' +import { setupContextMenus } from './contextMenus' import { - checkForInactiveTabs, - suspendTab, - suspendOtherTabs, - suspendAllTabs, - restoreAllTabs, - getTabCounts, - canSuspendTab, -} from './suspension' + setupSuspensionAlarm, + setupAutoSaveAlarm, + setupCloudSyncAlarm, + setupRecoverySnapshotAlarm, + setupExportReminderAlarm, +} from './alarms' +import { handleInstalled } from './lifecycle/onInstalled' +import { handleStartup } from './lifecycle/onStartup' import { - captureRecoverySnapshot, - debouncedCaptureSnapshot, - getRecoverySnapshots, - restoreFromSnapshot, - deleteRecoverySnapshot, - recoverySnapshotSync, - recoverySnapshotsStorage, -} from './recovery' -import { computeBackupHealth } from '@/shared/backupHealth' -import { - captureCurrentSession, - captureWindow, - restoreSession, - restoreSessionPartial, - saveSession, - deleteSession, - renameSession, - getAllSessions, - searchSessions, - performAutoSave, - getSessionStats, -} from './sessions' -import { getDuplicateCount, closeDuplicates } from './deduplication' - -// ============================================================================ -// State Tracking (persisted to survive service worker termination) -// ============================================================================ - -// Track previously active tab per window (for activity-on-leave tracking) -// When user switches away from a tab, we touch it to record the departure time -// NOTE: This is persisted to browser.storage to survive service worker restarts -let previousActiveTab: Map = new Map() // windowId → tabId - -// Initialization promise - listeners wait on this before accessing state -let initReady: Promise -let resolveInit: () => void -initReady = new Promise((resolve) => { - resolveInit = resolve -}) - -/** - * Load previousActiveTab from storage (call on init) - */ -async function loadPreviousActiveTabs(): Promise { - const stored = await storage.get>(STORAGE_KEYS.PREVIOUS_ACTIVE_TABS, {}) - previousActiveTab = new Map( - Object.entries(stored).map(([windowId, tabId]) => [parseInt(windowId, 10), tabId]) - ) -} - -/** - * Save previousActiveTab to storage (call on changes) - */ -async function savePreviousActiveTabs(): Promise { - const obj: Record = {} - for (const [windowId, tabId] of previousActiveTab) { - obj[String(windowId)] = tabId - } - await storage.set(STORAGE_KEYS.PREVIOUS_ACTIVE_TABS, obj) -} - -// ============================================================================ -// Hibernation Guard -// ============================================================================ - -/** - * Post-startup re-discard guard. - * - * After onStartup fires and Raft discards all eligible tabs, Chrome still - * does two annoying things during the next ~30 seconds: - * 1. Loads tabs that weren't discardable at the moment we asked (no main - * frame yet) — they come in fresh, un-discarded. - * 2. Undiscards recently-used tabs via its BackgroundTabLoadingPolicy. - * - * The guard catches both by re-discarding any tab-in-the-watch-list whose - * status transitions to 'complete' or whose `discarded` flag goes false - * inside the window (see the tabs.onUpdated listener). - * - * PWA QUIRK (commit 50d3d7b, issue #6): when Chrome is cold-started by a - * PWA, onStartup runs before any normal browser window exists. The regular - * window gets restored later — AFTER onStartup has already finished. That - * window's tabs never saw the initial discard pass, so `hibernateWindow()` - * (called from browser.windows.onCreated during the guard window) sweeps - * them up too. - * - * The 30s HIBERNATION_GUARD_DURATION_MS was tuned empirically against - * Chrome 131 with PWA-started sessions. Do NOT shorten without retesting - * the PWA path — shorter windows regress #6. - */ -async function maybeHibernateTab(tabId: number): Promise { - const result = await browser.storage.session.get(SESSION_KEYS.HIBERNATION_GUARD) - const guard = result[SESSION_KEYS.HIBERNATION_GUARD] as - | { expiresAt: number; tabIds: number[] } - | undefined - if (!guard) return - - if (Date.now() > guard.expiresAt) { - await browser.storage.session.remove(SESSION_KEYS.HIBERNATION_GUARD) - return - } - - if (!guard.tabIds.includes(tabId)) return - - const tab = await browser.tabs.get(tabId) - if (tab.active) return - if (tab.discarded) return - - console.log(`[Raft] Hibernation guard: discarding tab ${tabId} (${tab.url})`) - try { - await browser.tabs.discard(tabId) - } catch (e) { - console.warn(`[Raft] Hibernation guard: failed to discard tab ${tabId}:`, e) - } -} - -/** - * Hibernate all eligible tabs in a window. Used by the onCreated guard - * when a normal browser window appears after onStartup already ran - * (e.g., PWA started Chrome first, then the regular window restored). - */ -async function hibernateWindow(windowId: number): Promise { - const settings = await settingsStorage.get() - if (!settings.suspension.hibernateOnStartup) return - - const extensionOrigin = browser.runtime.getURL('') - const winTabs = await browser.tabs.query({ windowId }) - - // Open a Raft page as the active tab so we can discard the user's active tab - const raftTab = winTabs.find((t) => t.url?.startsWith(extensionOrigin)) - if (raftTab?.id) { - await browser.tabs.update(raftTab.id, { active: true }) - } else { - await browser.tabs.create({ - url: browser.runtime.getURL('src/options/index.html#sessions'), - active: true, - windowId, - }) - } - - const count = await suspendOtherTabs(windowId) - console.log(`[Raft] Hibernation guard: hibernated ${count} tabs in late window ${windowId}`) -} - -// ============================================================================ -// Message Types -// ============================================================================ - -import type { MessageResponse, Settings } from '@/shared/types' - -export type MessageType = - | { type: 'SUSPEND_TAB'; tabId: number } - | { type: 'SUSPEND_OTHER_TABS'; windowId?: number } - | { type: 'SUSPEND_ALL_TABS' } - | { type: 'RESTORE_ALL_TABS'; windowId?: number } - | { type: 'GET_TAB_COUNTS' } - | { type: 'GET_CURRENT_TAB_STATUS' } - | { type: 'GET_SETTINGS' } - | { type: 'UPDATE_SETTINGS'; settings: Partial } - // Session messages - | { type: 'SAVE_SESSION'; name?: string } - | { type: 'SAVE_WINDOW'; windowId: number; name?: string } - | { type: 'RESTORE_SESSION'; sessionId: string; asSuspended?: boolean } - | { type: 'GET_SESSIONS' } - | { type: 'DELETE_SESSION'; sessionId: string } - | { type: 'SEARCH_SESSIONS'; query: string } - // Cloud sync messages - | { type: 'CLOUD_CONNECT' } - | { type: 'CLOUD_DISCONNECT'; deleteCloudData?: boolean } - | { type: 'CLOUD_RECONNECT' } - | { type: 'CLOUD_SETUP_ENCRYPTION'; password: string; tokens?: CloudTokens; email?: string } - | { type: 'CLOUD_UNLOCK'; password: string; tokens?: CloudTokens; email?: string } - | { type: 'CLOUD_REGENERATE_RECOVERY_KEY'; password: string } - | { type: 'CLOUD_RECOVER_WITH_KEY'; recoveryKey: string; newPassword: string } - | { type: 'CLOUD_LOCK' } - | { type: 'CLOUD_SYNC' } - | { type: 'CLOUD_GET_STATUS' } - | { type: 'CLOUD_GET_SETTINGS' } - | { - type: 'CLOUD_UPDATE_SETTINGS' - settings: Partial - } - | { type: 'CLOUD_GET_SYNCED_IDS' } - // Pro licensing messages - | { type: 'PRO_CHECK_STATUS' } - | { type: 'PRO_OPEN_CHECKOUT' } - | { type: 'PRO_ACTIVATE_LICENSE'; licenseKey: string } - | { type: 'PRO_GET_LICENSE' } - | { type: 'PRO_CLEAR_LICENSE' } - // Browser sync status - | { type: 'GET_SYNC_STATUS' } - | { type: 'RESTORE_FROM_SYNC' } - | { type: 'CLEAR_SYNC_DATA' } - // Recovery snapshot messages - | { type: 'GET_RECOVERY_SNAPSHOTS' } - | { type: 'RESTORE_RECOVERY_SNAPSHOT'; snapshotId: string } - | { type: 'DELETE_RECOVERY_SNAPSHOT'; snapshotId: string } - // Export reminder messages - | { type: 'GET_EXPORT_REMINDER_STATE' } - | { type: 'DISMISS_EXPORT_REMINDER' } - | { type: 'MARK_EXPORT_COMPLETE' } - // Session rename - | { type: 'RENAME_SESSION'; sessionId: string; name: string } - // Tab deduplication messages - | { type: 'GET_DUPLICATE_COUNT' } - | { type: 'CLOSE_DUPLICATES' } - // Partial session restore - | { - type: 'RESTORE_SESSION_PARTIAL' - sessionId: string - asSuspended?: boolean - selection: import('@/shared/types').PartialRestoreSelection - } - // Backup health - | { type: 'GET_BACKUP_HEALTH' } - // Dev tools messages (dev mode only) - | { type: 'DEV_CREATE_SCENARIO'; scenario: import('@/devtools/types').DevScenario } - | { type: 'DEV_CLEANUP_TEST_WINDOWS' } - | { type: 'DEV_GET_TEST_WINDOW_IDS' } - -// Re-export for backwards compatibility -export type { MessageResponse } + handleAlarm, + handleTabActivated, + handleTabUpdated, + handleTabRemoved, + handleWindowCreated, + handleWindowRemoved, + handleContextMenuClick, + handleRuntimeMessage, + handleCommand, +} from './listeners' + +export type { MessageType, MessageResponse } from './messages/types' // ============================================================================ // Initialization // ============================================================================ -/** - * Initialize tab activity tracking for all existing tabs - * Only touches tabs that aren't already being tracked - */ async function initializeTabActivity(): Promise { const tabs = await browser.tabs.query({}) const activity = await tabActivityStorage.getAll() @@ -316,21 +70,16 @@ async function initializeTabActivity(): Promise { } /** - * Initialize the service worker - * Called on install, update, and every wake from termination + * Initialize the service worker. Called on install, update, and every wake. */ async function initialize(): Promise { - // Load settings (ensures defaults are set on first run) const settings = await settingsStorage.get() - // Initialize activity tracking for any untracked tabs await initializeTabActivity() - - // Load previousActiveTab from storage (persisted across service worker restarts) await loadPreviousActiveTabs() - // Populate initial active tabs per window (for activity-on-leave tracking) - // This handles service worker restart after termination + // Populate initial active tabs per window for activity-on-leave tracking + // (handles the case where the SW restarted and the map was empty). const windows = await browser.windows.getAll({ populate: true }) let needsSave = false for (const window of windows) { @@ -346,1411 +95,48 @@ async function initialize(): Promise { await savePreviousActiveTabs() } - // Set up alarms for suspension checking if (settings.suspension.enabled) { await setupSuspensionAlarm() } - - // Set up auto-save alarm if enabled if (settings.autoSave.enabled) { await setupAutoSaveAlarm(settings.autoSave.intervalMinutes) } - // Set up cloud sync alarm if enabled const cloudSyncSettings = await cloudSyncSettingsStorage.get() if (cloudSyncSettings.enabled && (await syncEngine.isConfigured())) { await setupCloudSyncAlarm(cloudSyncSettings.intervalMinutes) } - // Set up recovery snapshot alarm (always enabled) await setupRecoverySnapshotAlarm() - // Set up export reminder alarm if enabled if (settings.exportReminder.enabled) { await setupExportReminderAlarm() } - // Set up context menus await setupContextMenus() - - // Update badge with current counts await updateBadge() - resolveInit() -} - -/** - * Set up the suspension check alarm - */ -async function setupSuspensionAlarm(): Promise { - await browser.alarms.clear(ALARM_NAMES.SUSPENSION_CHECK) - await browser.alarms.create(ALARM_NAMES.SUSPENSION_CHECK, { - periodInMinutes: SUSPENSION_CHECK_INTERVAL_MINUTES, - }) -} - -/** - * Set up the auto-save alarm - */ -async function setupAutoSaveAlarm(intervalMinutes: number): Promise { - await browser.alarms.clear(ALARM_NAMES.AUTO_SAVE) - await browser.alarms.create(ALARM_NAMES.AUTO_SAVE, { - periodInMinutes: intervalMinutes, - }) -} - -/** - * Set up the cloud sync alarm - */ -async function setupCloudSyncAlarm(intervalMinutes: number): Promise { - await browser.alarms.clear(ALARM_NAMES.CLOUD_SYNC) - await browser.alarms.create(ALARM_NAMES.CLOUD_SYNC, { - periodInMinutes: intervalMinutes, - }) -} - -/** - * Set up the recovery snapshot alarm - */ -async function setupRecoverySnapshotAlarm(): Promise { - await browser.alarms.clear(ALARM_NAMES.RECOVERY_SNAPSHOT) - await browser.alarms.create(ALARM_NAMES.RECOVERY_SNAPSHOT, { - periodInMinutes: RECOVERY_CONFIG.INTERVAL_MINUTES, - }) -} - -/** - * Set up the export reminder alarm (runs daily to check if reminder is due) - */ -async function setupExportReminderAlarm(): Promise { - await browser.alarms.clear(ALARM_NAMES.EXPORT_REMINDER) - await browser.alarms.create(ALARM_NAMES.EXPORT_REMINDER, { - periodInMinutes: 60 * 24, // Check once per day - delayInMinutes: 60, // First check after 1 hour - }) -} - -/** - * Export reminder state stored in local storage - */ -interface ExportReminderState { - /** Whether a reminder is currently pending (not dismissed) */ - pending: boolean - /** Reason for the reminder */ - reason: 'time' | 'milestone' - /** For time-based: days since last export */ - daysSinceExport?: number - /** For milestone: the session count milestone reached */ - milestone?: number - /** Timestamp when reminder was triggered */ - triggeredAt: number -} - -/** - * Check if an export reminder should be shown and update the reminder state - */ -async function checkExportReminder(): Promise { - const settings = await settingsStorage.get() - - // Skip if reminders are disabled - if (!settings.exportReminder.enabled) { - return - } - - // Skip for Pro users (they have cloud backup) - if (await isProUser()) { - return - } - - const sessions = await sessionsStorage.getAll() - const sessionCount = sessions.length - - // Check for time-based reminder - const lastExportDate = settings.exportReminder.lastExportDate - if (lastExportDate) { - const daysSinceExport = Math.floor((Date.now() - lastExportDate) / (1000 * 60 * 60 * 24)) - if (daysSinceExport >= settings.exportReminder.intervalDays) { - // Time-based reminder is due - const state: ExportReminderState = { - pending: true, - reason: 'time', - daysSinceExport, - triggeredAt: Date.now(), - } - await storage.set(STORAGE_KEYS.EXPORT_REMINDER_STATE, state) - return - } - } else if (sessionCount > 0) { - // No export ever done - set initial lastExportDate to now so we don't nag immediately - // The reminder will trigger after intervalDays from now - await settingsStorage.update({ - exportReminder: { ...settings.exportReminder, lastExportDate: Date.now() }, - }) - } - - // Check for milestone-based reminder - const lastMilestone = settings.exportReminder.lastMilestoneReached ?? 0 - for (const milestone of EXPORT_REMINDER_CONFIG.MILESTONES) { - if (sessionCount >= milestone && milestone > lastMilestone) { - // New milestone reached! - const state: ExportReminderState = { - pending: true, - reason: 'milestone', - milestone, - triggeredAt: Date.now(), - } - await storage.set(STORAGE_KEYS.EXPORT_REMINDER_STATE, state) - // Update the last milestone so we don't trigger again for the same milestone - await settingsStorage.update({ - exportReminder: { ...settings.exportReminder, lastMilestoneReached: milestone }, - }) - return - } - } -} - -/** - * Set up context menus for right-click actions - */ -async function setupContextMenus(): Promise { - // Remove existing menus first - await browser.contextMenus.removeAll() - - // Add "Suspend this tab" menu item - try { - browser.contextMenus.create( - { - id: 'suspend-tab', - title: 'Suspend this tab', - contexts: ['page'], - }, - () => { - if (browser.runtime.lastError) { - console.warn('[Raft] Failed to create suspend-tab menu:', browser.runtime.lastError) - } - } - ) - } catch (err) { - console.warn('[Raft] Failed to create suspend-tab menu:', err) - } - - // Add "Suspend other tabs" menu item - try { - browser.contextMenus.create( - { - id: 'suspend-other-tabs', - title: 'Suspend other tabs in window', - contexts: ['page'], - }, - () => { - if (browser.runtime.lastError) { - console.warn( - '[Raft] Failed to create suspend-other-tabs menu:', - browser.runtime.lastError - ) - } - } - ) - } catch (err) { - console.warn('[Raft] Failed to create suspend-other-tabs menu:', err) - } -} - -/** - * Update the extension badge with suspended tab count - */ -async function updateBadge(): Promise { - const settings = await settingsStorage.get() - - if (!settings.ui.showBadge) { - await browser.action.setBadgeText({ text: '' }) - return - } - - const counts = await getTabCounts() - const text = counts.suspended > 0 ? counts.suspended.toString() : '' - - await browser.action.setBadgeText({ text }) - await browser.action.setBadgeBackgroundColor({ color: '#c07a42' }) // raft-500 + markInitReady() } // ============================================================================ -// Event Listeners -// ============================================================================ - -/** - * Handle alarm events - */ -browser.alarms.onAlarm.addListener(async (alarm) => { - switch (alarm.name) { - case ALARM_NAMES.SUSPENSION_CHECK: { - await checkForInactiveTabs() - await updateBadge() - - // Periodically clean up orphaned tab activity records - const tabs = await browser.tabs.query({}) - const tabIds = new Set(tabs.map((t) => t.id).filter((id): id is number => id !== undefined)) - await tabActivityStorage.cleanup(tabIds) - break - } - - case ALARM_NAMES.AUTO_SAVE: - await performAutoSave() - break - - case ALARM_NAMES.CLOUD_SYNC: - if ((await syncEngine.isConfigured()) && syncEngine.isUnlocked()) { - const syncState = await syncStateStorage.get() - if (!syncState.authExpired) { - await syncEngine.performFullSync() - } - } - break - - case ALARM_NAMES.RECOVERY_SNAPSHOT: - await captureRecoverySnapshot() - break - - case ALARM_NAMES.EXPORT_REMINDER: - await checkExportReminder() - break - } -}) - -/** - * Track tab activity for suspension timing - * - * Key insight: We track when the user LEAVES a tab, not when they arrive. - * This ensures tabs aren't suspended until X minutes after departure. - */ -browser.tabs.onActivated.addListener(async (activeInfo) => { - await initReady - - // Touch the PREVIOUS active tab (the one user just left) - const prevTabId = previousActiveTab.get(activeInfo.windowId) - if (prevTabId !== undefined) { - await tabActivityStorage.touch(prevTabId) - } - - // Store the new active tab for next time and persist to storage - previousActiveTab.set(activeInfo.windowId, activeInfo.tabId) - await savePreviousActiveTabs() - - await updateBadge() -}) - -/** - * Track tab updates (URL changes, discard state changes, etc.) - */ -browser.tabs.onUpdated.addListener(async (tabId, changeInfo) => { - // Hibernation guard: discard tabs that loaded during startup window - if (changeInfo.status === 'complete' || changeInfo.discarded === false) { - await maybeHibernateTab(tabId) - } - - // When a tab loads, mark it as active - if (changeInfo.status === 'complete') { - await tabActivityStorage.touch(tabId) - } - - // Update badge and trigger recovery snapshot when discard state changes - if (changeInfo.discarded !== undefined) { - await updateBadge() - // Debounced capture of recovery snapshot - debouncedCaptureSnapshot() - } - - // Update badge when URL changes (for tab restore) - if (changeInfo.url !== undefined) { - await updateBadge() - } -}) - -/** - * Clean up activity tracking when tabs are closed - */ -browser.tabs.onRemoved.addListener(async (tabId) => { - await tabActivityStorage.remove(tabId) - await updateBadge() -}) - -/** - * Hibernation guard: when a normal browser window appears during the guard - * window, hibernate its tabs. This handles the case where a PWA starts Chrome - * first (triggering onStartup before the regular window exists). - */ -browser.windows.onCreated.addListener(async (win) => { - if (win.type !== 'normal' || !win.id) return - await initReady - - const settings = await settingsStorage.get() - if (!settings.suspension.hibernateOnStartup) return - - // Only hibernate the first normal window — this is effectively a "startup" - // for the browser UI (e.g., PWA kept Chrome alive, user opens a browser window). - // If other normal windows already exist, this is just a new window (Ctrl+N). - const normalWindows = await browser.windows.getAll() - const normalCount = normalWindows.filter((w) => w.type === 'normal').length - if (normalCount > 1) return - - // Small delay to let Chrome finish creating/restoring tabs in the window - await new Promise((resolve) => setTimeout(resolve, 500)) - console.log(`[Raft] First normal window detected (${win.id}), hibernating...`) - await hibernateWindow(win.id) -}) - -/** - * Clean up previousActiveTab tracking when windows are closed - */ -browser.windows.onRemoved.addListener(async (windowId) => { - await initReady - previousActiveTab.delete(windowId) - await savePreviousActiveTabs() -}) - -/** - * Handle context menu clicks - */ -browser.contextMenus.onClicked.addListener(async (info, tab) => { - if (!tab?.id) return - - switch (info.menuItemId) { - case 'suspend-tab': - await suspendTab(tab.id) - await updateBadge() - break - - case 'suspend-other-tabs': - await suspendOtherTabs(tab.windowId) - await updateBadge() - break - } -}) - -/** - * Handle messages from popup and other extension pages - */ -browser.runtime.onMessage.addListener((message: MessageType, sender, sendResponse) => { - // Only accept messages from our own extension - if (sender.id !== browser.runtime.id) { - sendResponse({ success: false, error: 'Unauthorized sender' }) - return true - } - - handleMessage(message) - .then(sendResponse) - .catch((err) => { - console.error('[Raft] Message handler error:', err) - sendResponse({ success: false, error: String(err) }) - }) - return true // Keep channel open for async response -}) - -// ============================================================================ -// Dev Tools Functions (only used in development) +// Event Listeners (registered synchronously at module top level) // ============================================================================ -/** - * Get the list of test window IDs - */ -async function getTestWindowIds(): Promise { - const windowIds = await storage.get(DEV_TEST_WINDOWS_KEY, []) - // Filter out any windows that no longer exist - const existingWindows = await browser.windows.getAll() - const existingIds = new Set(existingWindows.map((w) => w.id)) - const validIds = windowIds.filter((id) => existingIds.has(id)) - // Update storage if some windows were closed - if (validIds.length !== windowIds.length) { - await storage.set(DEV_TEST_WINDOWS_KEY, validIds) - } - return validIds -} - -/** - * Add a window ID to the test windows list - */ -async function addTestWindowId(windowId: number): Promise { - const windowIds = await getTestWindowIds() - if (!windowIds.includes(windowId)) { - windowIds.push(windowId) - await storage.set(DEV_TEST_WINDOWS_KEY, windowIds) - } -} - -/** - * Create a dev test scenario - */ -async function createDevScenario( - scenario: import('@/devtools/types').DevScenario -): Promise<{ windowCount: number; tabCount: number }> { - let totalTabs = 0 - - for (const windowSpec of scenario.windows) { - // Create window with about:blank - const createdWindow = await browser.windows.create({ - url: 'about:blank', - focused: windowSpec.focused ?? false, - }) - - const windowId = createdWindow?.id - if (windowId === undefined) continue - await addTestWindowId(windowId) - - // Get the initial blank tab to remove later - const initialTabs = await browser.tabs.query({ windowId }) - const blankTabId = initialTabs[0]?.id - - // Create ungrouped tabs - if (windowSpec.tabs) { - for (const tabSpec of windowSpec.tabs) { - await browser.tabs.create({ - windowId, - url: tabSpec.url, - pinned: tabSpec.pinned ?? false, - active: tabSpec.active ?? false, - }) - totalTabs++ - } - } - - // Create grouped tabs - if (windowSpec.groups) { - for (const groupSpec of windowSpec.groups) { - const tabIds: number[] = [] - - // Create tabs for this group - for (const tabSpec of groupSpec.tabs) { - const tab = await browser.tabs.create({ - windowId, - url: tabSpec.url, - pinned: tabSpec.pinned ?? false, - active: tabSpec.active ?? false, - }) - if (tab.id) { - tabIds.push(tab.id) - totalTabs++ - } - } - - // Group the tabs (requires at least one tab) - if (tabIds.length > 0) { - // Cast to the required tuple type - const tabIdsForGroup = tabIds as [number, ...number[]] - const groupId = await browser.tabs.group({ - tabIds: tabIdsForGroup, - createProperties: { windowId }, - }) - - // Update group properties - await browser.tabGroups.update(groupId, { - title: groupSpec.title, - color: groupSpec.color as browser.tabGroups.Color, - collapsed: groupSpec.collapsed ?? false, - }) - } - } - } - - // Remove the initial blank tab - if (blankTabId) { - try { - await browser.tabs.remove(blankTabId) - } catch { - // Tab may already be closed - } - } - } - - return { windowCount: scenario.windows.length, tabCount: totalTabs } -} - -/** - * Clean up all test windows - */ -async function cleanupTestWindows(): Promise<{ closedCount: number }> { - const windowIds = await getTestWindowIds() - let closedCount = 0 - - for (const windowId of windowIds) { - try { - await browser.windows.remove(windowId) - closedCount++ - } catch { - // Window may already be closed - } - } - - // Clear the list - await storage.set(DEV_TEST_WINDOWS_KEY, []) - - return { closedCount } -} - -/** - * Process incoming messages - */ -async function handleMessage(message: MessageType): Promise { - try { - switch (message.type) { - case 'SUSPEND_TAB': { - const suspended = await suspendTab(message.tabId) - await updateBadge() - if (suspended) { - return { success: true, data: { suspended: true } } - } - return { success: false, error: 'Tab could not be suspended' } - } - - case 'SUSPEND_OTHER_TABS': { - const count = await suspendOtherTabs(message.windowId) - await updateBadge() - return { success: true, data: { suspended: count } } - } - - case 'SUSPEND_ALL_TABS': { - const count = await suspendAllTabs() - await updateBadge() - return { success: true, data: { suspended: count } } - } - - case 'RESTORE_ALL_TABS': { - const count = await restoreAllTabs(message.windowId) - await updateBadge() - return { success: true, data: { restored: count } } - } - - case 'GET_TAB_COUNTS': { - const counts = await getTabCounts() - return { success: true, data: counts } - } - - case 'GET_CURRENT_TAB_STATUS': { - const [tab] = await browser.tabs.query({ active: true, currentWindow: true }) - if (!tab) { - return { success: false, error: 'No active tab' } - } - const check = await canSuspendTab(tab) - const suspended = tab.discarded ?? false - return { - success: true, - data: { - tab: { - id: tab.id, - title: tab.title, - url: tab.url, - suspended, - pinned: tab.pinned, - audible: tab.audible, - }, - canSuspend: check.canSuspend, - reason: check.reason, - }, - } - } - - case 'GET_SETTINGS': { - const settings = await settingsStorage.get() - return { success: true, data: settings } - } - - case 'UPDATE_SETTINGS': { - const settings = await settingsStorage.update(message.settings) - - // Re-setup alarms based on new settings - if (settings.suspension.enabled) { - await setupSuspensionAlarm() - } else { - await browser.alarms.clear(ALARM_NAMES.SUSPENSION_CHECK) - } - - if (settings.autoSave.enabled) { - await setupAutoSaveAlarm(settings.autoSave.intervalMinutes) - } else { - await browser.alarms.clear(ALARM_NAMES.AUTO_SAVE) - } - - if (settings.exportReminder.enabled) { - await setupExportReminderAlarm() - } else { - await browser.alarms.clear(ALARM_NAMES.EXPORT_REMINDER) - } - - await updateBadge() - return { success: true, data: settings } - } - - // ========== Session Messages ========== - - case 'SAVE_SESSION': { - const session = await captureCurrentSession(message.name, 'manual') - await saveSession(session) - return { success: true, data: { session, stats: getSessionStats(session) } } - } - - case 'SAVE_WINDOW': { - const session = await captureWindow(message.windowId, message.name) - await saveSession(session) - return { success: true, data: { session, stats: getSessionStats(session) } } - } - - case 'RESTORE_SESSION': { - const result = await restoreSession(message.sessionId, { - asSuspended: message.asSuspended, - }) - return { success: true, data: result } - } - - case 'GET_SESSIONS': { - const sessions = await getAllSessions() - const sessionsWithStats = sessions.map((s) => ({ - ...s, - stats: getSessionStats(s), - })) - // Sort by most recent first - sessionsWithStats.sort((a, b) => b.createdAt - a.createdAt) - return { success: true, data: sessionsWithStats } - } - - case 'DELETE_SESSION': { - await deleteSession(message.sessionId) - return { success: true } - } - - case 'RENAME_SESSION': { - await renameSession(message.sessionId, message.name) - return { success: true } - } - - case 'SEARCH_SESSIONS': { - const sessions = await searchSessions(message.query) - const sessionsWithStats = sessions.map((s) => ({ - ...s, - stats: getSessionStats(s), - })) - sessionsWithStats.sort((a, b) => b.createdAt - a.createdAt) - return { success: true, data: sessionsWithStats } - } - - // ========== Cloud Sync Messages ========== - - case 'CLOUD_CONNECT': { - // Check Pro status first - if (!(await canUseCloudSync())) { - return { success: false, error: 'Cloud sync requires Pro. Please upgrade.' } - } - - // Launch OAuth flow and get tokens - const result = await launchGoogleOAuth() - - // Tier 1: Check if encryption key data exists locally - const existingKeyData = await encryptionKeyStorage.get() - if (existingKeyData) { - return { - success: true, - data: { - needsUnlock: true, - email: result.email, - tokens: result.tokens, - }, - } - } - - // Tier 2: No local data — check Drive for key data from a previous install - try { - const driveKeyData = await gdrive.downloadKeyData(result.tokens.accessToken) - if (driveKeyData) { - // Restore key data locally so unlock flow works - await encryptionKeyStorage.save({ - salt: driveKeyData.salt, - verificationHash: driveKeyData.verificationHash, - }) - return { - success: true, - data: { - needsUnlock: true, - email: result.email, - tokens: result.tokens, - }, - } - } - } catch (err) { - // Drive failure is non-fatal — fall through to new setup - console.warn('[Raft] Failed to check Drive for existing key data:', err) - } - - // Tier 3: No data anywhere — truly new user - return { - success: true, - data: { - needsEncryptionSetup: true, - email: result.email, - tokens: result.tokens, - }, - } - } - - case 'CLOUD_SETUP_ENCRYPTION': { - // Set up encryption with user's password - const { keyData, recoveryKey, key } = await setupEncryption(message.password) - - // Get tokens from message parameter (passed directly from UI, never stored in plaintext) - const pendingTokens = message.tokens - const pendingEmail = message.email - if (!pendingTokens || !pendingEmail) { - return { success: false, error: 'No pending connection. Please reconnect.' } - } - - // Encrypt and save tokens - const encryptedTokens = await encryptObject(pendingTokens, key) - await cloudCredentialsStorage.save({ - provider: 'gdrive', - encryptedTokens: JSON.stringify(encryptedTokens), - email: pendingEmail, - connectedAt: Date.now(), - }) - - // Also encrypt tokens with recovery key for actual recovery support - const recoveryDerivedKey = await deriveKeyFromRecovery(recoveryKey, keyData.salt) - const recoveryEncrypted = await encryptObject(pendingTokens, recoveryDerivedKey) - keyData.recoveryPayload = JSON.stringify(recoveryEncrypted) - - // Save key data (includes recovery payload) - await encryptionKeyStorage.save(keyData) - - // Upload key data to Drive for future reinstall detection (non-fatal) - try { - await gdrive.uploadKeyData(pendingTokens.accessToken, { - salt: keyData.salt, - verificationHash: keyData.verificationHash, - }) - } catch (err) { - console.warn('[Raft] Failed to upload key data to Drive:', err) - } - - // Enable cloud sync - await cloudSyncSettingsStorage.update({ enabled: true }) - - // Set up sync alarm - const syncSettings = await cloudSyncSettingsStorage.get() - await setupCloudSyncAlarm(syncSettings.intervalMinutes) - - return { - success: true, - data: { recoveryKey }, - } - } - - case 'CLOUD_UNLOCK': { - const unlocked = await syncEngine.unlock(message.password) - if (!unlocked) { - return { success: false, error: 'Incorrect password' } - } - - // If tokens were passed (from a new connect flow), encrypt and save them - if (message.tokens && message.email) { - const unlockKey = syncEngine.getEncryptionKeyForSetup() - if (unlockKey) { - const encryptedTokens = await encryptObject(message.tokens, unlockKey) - await cloudCredentialsStorage.save({ - provider: 'gdrive', - encryptedTokens: JSON.stringify(encryptedTokens), - email: message.email, - connectedAt: Date.now(), - }) - - // Enable cloud sync - await cloudSyncSettingsStorage.update({ enabled: true }) - const syncSettings = await cloudSyncSettingsStorage.get() - await setupCloudSyncAlarm(syncSettings.intervalMinutes) - } - } - - // Process any pending queue items - await syncEngine.processQueue() - - return { success: true } - } - - case 'CLOUD_LOCK': { - syncEngine.lock() - return { success: true } - } - - case 'CLOUD_REGENERATE_RECOVERY_KEY': { - const keyData = await encryptionKeyStorage.get() - if (!keyData) { - return { success: false, error: 'Encryption not set up' } - } - - // Verify password - const key = await deriveKey(message.password, keyData.salt) - const hash = await createVerificationHash(key, keyData.salt) - if (hash !== keyData.verificationHash) { - return { success: false, error: 'Incorrect password' } - } - - // Decrypt tokens with password key - const credentials = await cloudCredentialsStorage.get() - if (!credentials) { - return { success: false, error: 'No cloud credentials found' } - } - const payload = JSON.parse(credentials.encryptedTokens) - const tokens = await decryptObject(payload, key) - - // Generate new recovery key and encrypt tokens with it - const newRecoveryKey = generateRecoveryKey() - const recoveryDerivedKey = await deriveKeyFromRecovery(newRecoveryKey, keyData.salt) - const recoveryEncrypted = await encryptObject(tokens, recoveryDerivedKey) - - // Save updated key data with new recovery payload - await encryptionKeyStorage.save({ - ...keyData, - recoveryPayload: JSON.stringify(recoveryEncrypted), - }) - - return { success: true, data: { recoveryKey: newRecoveryKey } } - } - - case 'CLOUD_RECOVER_WITH_KEY': { - // Recovery flow: verify identity via recovery key, set new password, wipe & re-sync - const keyData = await encryptionKeyStorage.get() - if (!keyData || !keyData.recoveryPayload) { - return { success: false, error: 'No recovery data available' } - } - - // Step 1: Validate recovery key by decrypting the recovery payload - let tokens: CloudTokens - try { - const recoveryDerivedKey = await deriveKeyFromRecovery(message.recoveryKey, keyData.salt) - const recoveryPayload = JSON.parse(keyData.recoveryPayload) as EncryptedPayload - tokens = await decryptObject(recoveryPayload, recoveryDerivedKey) - } catch { - return { success: false, error: 'Invalid recovery key' } - } - - // Step 2: Derive new encryption key from new password with a fresh salt - const newSalt = generateSalt() - const newKey = await deriveKey(message.newPassword, newSalt) - const newVerificationHash = await createVerificationHash(newKey, newSalt) - - // Step 3: Encrypt tokens with the new key - const newEncryptedTokens = await encryptObject(tokens, newKey) - - // Step 4: Generate new recovery key + recovery payload - const newRecoveryKey = generateRecoveryKey() - const newRecoveryDerivedKey = await deriveKeyFromRecovery(newRecoveryKey, newSalt) - const newRecoveryEncrypted = await encryptObject(tokens, newRecoveryDerivedKey) - - // Step 5: Save updated encryption key data - await encryptionKeyStorage.save({ - salt: newSalt, - verificationHash: newVerificationHash, - recoveryPayload: JSON.stringify(newRecoveryEncrypted), - }) - - // Step 6: Save re-encrypted credentials - const credentials = await cloudCredentialsStorage.get() - if (credentials) { - await cloudCredentialsStorage.save({ - ...credentials, - encryptedTokens: JSON.stringify(newEncryptedTokens), - }) - } - - // Step 7: Unlock sync engine with new key - syncEngine.setEncryptionKey(newKey) - - // Step 8: Wipe old encrypted data from Drive & upload new key metadata - try { - await gdrive.clearAllData(tokens.accessToken) - await gdrive.uploadKeyData(tokens.accessToken, { - salt: newSalt, - verificationHash: newVerificationHash, - }) - } catch (err) { - console.warn('[Raft] Recovery: failed to reset Drive data:', err) - } - - // Step 9: Re-upload all local sessions with new encryption (fire-and-forget) - syncEngine.performFullSync().catch((err: unknown) => { - console.error('[Raft] Recovery: post-recovery sync failed:', err) - }) - - return { success: true, data: { recoveryKey: newRecoveryKey } } - } - - case 'CLOUD_DISCONNECT': { - // If unlocked, we can revoke tokens and optionally delete cloud data - if (syncEngine.isUnlocked()) { - try { - const tokens = await syncEngine.getValidTokensForDisconnect() - if (tokens) { - // Delete cloud data if requested - if (message.deleteCloudData) { - await gdrive.clearAllData(tokens.accessToken) - } - // Revoke OAuth access (best-effort) - try { - await revokeAccess(tokens.accessToken) - } catch { - // User might have already revoked in Google settings - } - } - } catch { - // Don't block disconnect on cleanup errors - } - } - - // Clear all local cloud sync data - await clearAllCloudSyncData() - - // Cancel sync alarm - await browser.alarms.clear(ALARM_NAMES.CLOUD_SYNC) - - return { success: true } - } - - case 'CLOUD_RECONNECT': { - if (!(await syncEngine.isConfigured())) { - return { success: false, error: 'Cloud sync not configured' } - } - if (!syncEngine.isUnlocked()) { - return { success: false, error: 'Cloud sync is locked' } - } - - // Launch fresh OAuth flow - const reconnectResult = await launchGoogleOAuth() - - // Encrypt new tokens with existing encryption key - const reconnectKey = syncEngine.getEncryptionKeyForSetup() - if (!reconnectKey) { - return { success: false, error: 'Encryption key not available' } - } - - const reconnectEncrypted = await encryptObject(reconnectResult.tokens, reconnectKey) - - // Save new credentials, preserving existing connectedAt - const existingCreds = await cloudCredentialsStorage.get() - await cloudCredentialsStorage.save({ - provider: 'gdrive', - encryptedTokens: JSON.stringify(reconnectEncrypted), - email: reconnectResult.email, - connectedAt: existingCreds?.connectedAt ?? Date.now(), - }) - - // Clear cached tokens so sync engine picks up new ones - syncEngine.clearCachedTokens() - - // Clear auth error state - await syncStateStorage.update({ authExpired: false, lastError: undefined }) - - return { success: true, data: { email: reconnectResult.email } } - } - - case 'CLOUD_SYNC': { - if (!(await syncEngine.isConfigured())) { - return { success: false, error: 'Cloud sync not configured' } - } - if (!syncEngine.isUnlocked()) { - return { success: false, error: 'Cloud sync is locked' } - } - - const result = await syncEngine.performFullSync() - if (result.success) { - return { success: true, data: result } - } else { - return { success: false, error: result.errors[0] || 'Sync failed' } - } - } - - case 'CLOUD_GET_STATUS': { - const status = await syncEngine.getSyncStatus() - return { success: true, data: status } - } - - case 'CLOUD_GET_SETTINGS': { - const settings = await cloudSyncSettingsStorage.get() - return { success: true, data: settings } - } - - case 'CLOUD_UPDATE_SETTINGS': { - const settings = await cloudSyncSettingsStorage.update(message.settings) - - // Update sync alarm if interval changed - if (settings.enabled) { - await setupCloudSyncAlarm(settings.intervalMinutes) - } else { - await browser.alarms.clear(ALARM_NAMES.CLOUD_SYNC) - } - - return { success: true, data: settings } - } - - case 'CLOUD_GET_SYNCED_IDS': { - const result = await browser.storage.local.get(CLOUD_SYNC_KEYS.SYNCED_IDS) - const ids = (result[CLOUD_SYNC_KEYS.SYNCED_IDS] as string[] | undefined) ?? [] - return { success: true, data: ids } - } - - // ========== Pro Licensing Messages ========== - - case 'PRO_CHECK_STATUS': { - const isPro = await isProUser() - const { email } = isPro ? await checkLicense() : { email: undefined } - return { success: true, data: { isPro, email } } - } - - case 'PRO_OPEN_CHECKOUT': { - openCheckoutPage() - return { success: true } - } - - case 'PRO_ACTIVATE_LICENSE': { - const license = await activateLicense(message.licenseKey) - if (license && license.status === 'active') { - return { success: true, data: { license } } - } - return { success: false, error: 'Invalid or inactive license key' } - } - - case 'PRO_GET_LICENSE': { - const license = await getStoredLicense() - return { success: true, data: { license } } - } - - case 'PRO_CLEAR_LICENSE': { - await clearLicense() - return { success: true } - } - - // ========== Browser Sync Status ========== - - case 'GET_SYNC_STATUS': { - const status = await getSyncStatus() - return { success: true, data: status } - } - - case 'RESTORE_FROM_SYNC': { - const restoredSessions = await restoreFromSync() - for (const session of restoredSessions) { - await sessionsStorage.save(session) - } - return { success: true, data: { count: restoredSessions.length } } - } - - case 'CLEAR_SYNC_DATA': { - await clearSyncData() - return { success: true } - } - - // ========== Recovery Snapshots ========== - - case 'GET_RECOVERY_SNAPSHOTS': { - const snapshots = await getRecoverySnapshots() - return { success: true, data: snapshots } - } - - case 'RESTORE_RECOVERY_SNAPSHOT': { - const result = await restoreFromSnapshot(message.snapshotId) - if (result) { - return { success: true, data: result } - } - return { success: false, error: 'Failed to restore from snapshot' } - } - - case 'DELETE_RECOVERY_SNAPSHOT': { - const deleted = await deleteRecoverySnapshot(message.snapshotId) - if (deleted) { - return { success: true } - } - return { success: false, error: 'Failed to delete snapshot' } - } - - // ========== Export Reminder Messages ========== - - case 'GET_EXPORT_REMINDER_STATE': { - const state = await storage.get( - STORAGE_KEYS.EXPORT_REMINDER_STATE, - null - ) - return { success: true, data: state } - } - - case 'DISMISS_EXPORT_REMINDER': { - // Clear the pending reminder - await storage.remove(STORAGE_KEYS.EXPORT_REMINDER_STATE) - return { success: true } - } - - case 'MARK_EXPORT_COMPLETE': { - // Update lastExportDate and clear any pending reminder - const settings = await settingsStorage.get() - await settingsStorage.update({ - exportReminder: { ...settings.exportReminder, lastExportDate: Date.now() }, - }) - await storage.remove(STORAGE_KEYS.EXPORT_REMINDER_STATE) - return { success: true } - } - - // ========== Tab Deduplication Messages ========== - - case 'GET_DUPLICATE_COUNT': { - const count = await getDuplicateCount() - return { success: true, data: { count } } - } - - case 'CLOSE_DUPLICATES': { - const result = await closeDuplicates() - await updateBadge() - return { success: true, data: result } - } - - // ========== Partial Session Restore ========== - - case 'RESTORE_SESSION_PARTIAL': { - const result = await restoreSessionPartial(message.sessionId, { - asSuspended: message.asSuspended, - selection: message.selection, - }) - return { success: true, data: result } - } - - // ========== Backup Health ========== - - case 'GET_BACKUP_HEALTH': { - const [allSessions, healthSettings, browserSyncStatus, cloudStatus, snapshots, isPro] = - await Promise.all([ - getAllSessions(), - settingsStorage.get(), - getSyncStatus(), - syncEngine.getSyncStatus(), - getRecoverySnapshots(), - isProUser(), - ]) - - // Derive lastAutoSaveAt from most recent auto-save session - const autoSaves = allSessions - .filter((s) => s.source === 'auto') - .sort((a, b) => b.createdAt - a.createdAt) - const lastAutoSaveAt = autoSaves.length > 0 ? autoSaves[0].createdAt : undefined - - const healthInput = { - totalSessions: allSessions.length, - autoSaveEnabled: healthSettings.autoSave.enabled, - lastAutoSaveAt, - recoverySnapshotCount: snapshots.length, - lastRecoveryAt: snapshots.length > 0 ? snapshots[0].timestamp : undefined, - browserSync: { - sessionCount: browserSyncStatus.sessionCount, - totalBytes: browserSyncStatus.totalBytes, - maxBytes: browserSyncStatus.maxBytes, - percentUsed: browserSyncStatus.percentUsed, - }, - cloudSync: { - configured: cloudStatus.configured, - enabled: cloudStatus.enabled, - unlocked: cloudStatus.unlocked, - lastSyncAt: cloudStatus.lastSyncAt, - lastError: cloudStatus.lastError, - syncing: cloudStatus.syncing, - }, - isPro, - exportReminderLastExport: healthSettings.exportReminder.lastExportDate, - } - - const health = computeBackupHealth(healthInput) - return { success: true, data: health } - } - - // ========== Dev Tools Messages (dev mode only) ========== - - case 'DEV_CREATE_SCENARIO': { - if (!import.meta.env.DEV) { - return { success: false, error: 'Dev tools are only available in development mode' } - } - const result = await createDevScenario(message.scenario) - return { success: true, data: result } - } - - case 'DEV_CLEANUP_TEST_WINDOWS': { - if (!import.meta.env.DEV) { - return { success: false, error: 'Dev tools are only available in development mode' } - } - const result = await cleanupTestWindows() - return { success: true, data: result } - } - - case 'DEV_GET_TEST_WINDOW_IDS': { - if (!import.meta.env.DEV) { - return { success: false, error: 'Dev tools are only available in development mode' } - } - const windowIds = await getTestWindowIds() - return { success: true, data: { windowIds } } - } - - default: - return { success: false, error: 'Unknown message type' } - } - } catch (error) { - console.error('[Raft] Message handler error:', error) - return { success: false, error: String(error) } - } -} - -/** - * Handle extension install/update - */ -browser.runtime.onInstalled.addListener(async (details) => { - console.log('[Raft] Extension installed/updated:', details.reason) - - if (details.reason === 'install') { - // Check if we should restore sessions from sync (cross-device scenario) - // Note: This works when installing on a new device with the same Chrome profile. - // Sync storage does NOT survive uninstall, so this won't restore after reinstall. - const localSessions = await sessionsStorage.getAll() - if (await shouldRestoreFromSync(localSessions.length)) { - console.log('[Raft] Found sync backup from another device, restoring sessions...') - const restoredSessions = await restoreFromSync() - - // Save restored sessions to local storage - for (const session of restoredSessions) { - await sessionsStorage.save(session) - } - - console.log(`[Raft] Restored ${restoredSessions.length} sessions from sync backup`) - } - - // Check if we should restore recovery snapshot from sync (cross-device scenario) - const localSnapshots = await recoverySnapshotsStorage.getAll() - if (localSnapshots.length === 0) { - const syncedSnapshot = await recoverySnapshotSync.get() - if (syncedSnapshot) { - await recoverySnapshotsStorage.save(syncedSnapshot) - console.log( - `[Raft] Restored recovery snapshot from sync (${syncedSnapshot.stats.tabCount} tabs)` - ) - } - } - - // Open onboarding page for new users - const onboardingUrl = browser.runtime.getURL('src/onboarding/index.html') - browser.tabs.create({ url: onboardingUrl }) - } else if (details.reason === 'update') { - console.log('[Raft] Updated from version:', details.previousVersion) - - // Migration: Remove old live backup session (replaced by recovery snapshots) - try { - await sessionsStorage.delete('raft:live-backup') - console.log('[Raft] Migrated: removed old live backup session') - } catch { - // Ignore if doesn't exist - } - - // On update, ensure existing sessions are backed up to sync - // This helps users who upgrade from before sync was added - const sessions = await sessionsStorage.getAll() - const manualSessions = sessions.filter((s) => s.source !== 'auto' && s.source !== 'backup') - - // Backup up to 10 most recent manual sessions (to not overwhelm sync) - const toBackup = manualSessions.sort((a, b) => b.createdAt - a.createdAt).slice(0, 10) - - for (const session of toBackup) { - await backupSession(session) - } - } - // Don't call initialize() here - it runs at the bottom of the script -}) - -/** - * Handle service worker startup (wake from termination) - */ +browser.alarms.onAlarm.addListener(handleAlarm) +browser.tabs.onActivated.addListener(handleTabActivated) +browser.tabs.onUpdated.addListener(handleTabUpdated) +browser.tabs.onRemoved.addListener(handleTabRemoved) +browser.windows.onCreated.addListener(handleWindowCreated) +browser.windows.onRemoved.addListener(handleWindowRemoved) +browser.contextMenus.onClicked.addListener(handleContextMenuClick) +browser.runtime.onMessage.addListener(handleRuntimeMessage) +browser.runtime.onInstalled.addListener(handleInstalled) browser.runtime.onStartup.addListener(async () => { - // Don't call initialize() here - it runs at the bottom of the script await initReady - const settings = await settingsStorage.get() - if (settings.suspension.hibernateOnStartup) { - console.log('[Raft] Hibernate on startup enabled, suspending all tabs') - const allWindows = await browser.windows.getAll() - const windows = allWindows.filter((w) => w.type === 'normal') - const extensionOrigin = browser.runtime.getURL('') - const hibernateTabIds: number[] = [] - for (const win of windows) { - if (!win.id) continue - // We need a Raft extension page as the active tab so browser.tabs.discard() - // can suspend the user's previously-active tab. Reuse one if already open. - const winTabs = await browser.tabs.query({ windowId: win.id }) - const raftTab = winTabs.find((t) => t.url?.startsWith(extensionOrigin)) - if (raftTab?.id) { - await browser.tabs.update(raftTab.id, { active: true }) - } else { - await browser.tabs.create({ - url: browser.runtime.getURL('src/options/index.html#sessions'), - active: true, - windowId: win.id, - }) - } - // Record all non-active, non-protected tabs for the hibernation guard - for (const t of winTabs) { - if ( - t.id && - !t.active && - t.url && - !t.url.startsWith(extensionOrigin) && - !PROTECTED_URL_PATTERNS.some((p) => t.url!.startsWith(p)) - ) { - hibernateTabIds.push(t.id) - } - } - const count = await suspendOtherTabs(win.id) - console.log(`[Raft] Hibernated ${count} tabs in window ${win.id}`) - } - // Guard catches tabs that couldn't be discarded yet (no main frame), - // tabs Chrome's startup loader undiscards, and normal windows that - // appear after onStartup (e.g., PWA started Chrome first) - await browser.storage.session.set({ - [SESSION_KEYS.HIBERNATION_GUARD]: { - expiresAt: Date.now() + HIBERNATION_GUARD_DURATION_MS, - tabIds: hibernateTabIds, - }, - }) - console.log( - `[Raft] Hibernation guard set for ${hibernateTabIds.length} tabs (${HIBERNATION_GUARD_DURATION_MS / 1000}s window)` - ) - } -}) - -// Handle keyboard commands -browser.commands.onCommand.addListener(async (command) => { - switch (command) { - case 'suspend-current-tab': { - const [tab] = await browser.tabs.query({ active: true, currentWindow: true }) - if (tab?.id) { - await suspendTab(tab.id) - await updateBadge() - } - break - } - - case 'suspend-other-tabs': { - const window = await browser.windows.getCurrent() - await suspendOtherTabs(window.id) - await updateBadge() - break - } - - case 'close-duplicates': { - await closeDuplicates() - await updateBadge() - break - } - - case 'save-session': { - const session = await captureCurrentSession(undefined, 'manual') - await saveSession(session) - break - } - } + await handleStartup() }) +browser.commands.onCommand.addListener(handleCommand) // Initialize on load (handles both fresh start and wake from termination) initialize() diff --git a/src/background/lifecycle/hibernation.ts b/src/background/lifecycle/hibernation.ts new file mode 100644 index 0000000..74636da --- /dev/null +++ b/src/background/lifecycle/hibernation.ts @@ -0,0 +1,83 @@ +/** + * Post-startup re-discard guard. + * + * After onStartup fires and Raft discards all eligible tabs, Chrome still + * does two annoying things during the next ~30 seconds: + * 1. Loads tabs that weren't discardable at the moment we asked (no main + * frame yet) — they come in fresh, un-discarded. + * 2. Undiscards recently-used tabs via its BackgroundTabLoadingPolicy. + * + * The guard catches both by re-discarding any tab-in-the-watch-list whose + * status transitions to 'complete' or whose `discarded` flag goes false + * inside the window (see the tabs.onUpdated listener). + * + * PWA QUIRK (commit 50d3d7b, issue #6): when Chrome is cold-started by a + * PWA, onStartup runs before any normal browser window exists. The regular + * window gets restored later — AFTER onStartup has already finished. That + * window's tabs never saw the initial discard pass, so `hibernateWindow()` + * (called from browser.windows.onCreated during the guard window) sweeps + * them up too. + * + * The 30s HIBERNATION_GUARD_DURATION_MS was tuned empirically against + * Chrome 131 with PWA-started sessions. Do NOT shorten without retesting + * the PWA path — shorter windows regress #6. + */ + +import { browser } from '@/shared/browser' +import { settingsStorage } from '@/shared/storage' +import { SESSION_KEYS } from '@/shared/constants' +import { suspendOtherTabs } from '../suspension' + +export async function maybeHibernateTab(tabId: number): Promise { + const result = await browser.storage.session.get(SESSION_KEYS.HIBERNATION_GUARD) + const guard = result[SESSION_KEYS.HIBERNATION_GUARD] as + | { expiresAt: number; tabIds: number[] } + | undefined + if (!guard) return + + if (Date.now() > guard.expiresAt) { + await browser.storage.session.remove(SESSION_KEYS.HIBERNATION_GUARD) + return + } + + if (!guard.tabIds.includes(tabId)) return + + const tab = await browser.tabs.get(tabId) + if (tab.active) return + if (tab.discarded) return + + console.log(`[Raft] Hibernation guard: discarding tab ${tabId} (${tab.url})`) + try { + await browser.tabs.discard(tabId) + } catch (e) { + console.warn(`[Raft] Hibernation guard: failed to discard tab ${tabId}:`, e) + } +} + +/** + * Hibernate all eligible tabs in a window. Used by the onCreated guard + * when a normal browser window appears after onStartup already ran + * (e.g., PWA started Chrome first, then the regular window restored). + */ +export async function hibernateWindow(windowId: number): Promise { + const settings = await settingsStorage.get() + if (!settings.suspension.hibernateOnStartup) return + + const extensionOrigin = browser.runtime.getURL('') + const winTabs = await browser.tabs.query({ windowId }) + + // Open a Raft page as the active tab so we can discard the user's active tab + const raftTab = winTabs.find((t) => t.url?.startsWith(extensionOrigin)) + if (raftTab?.id) { + await browser.tabs.update(raftTab.id, { active: true }) + } else { + await browser.tabs.create({ + url: browser.runtime.getURL('src/options/index.html#sessions'), + active: true, + windowId, + }) + } + + const count = await suspendOtherTabs(windowId) + console.log(`[Raft] Hibernation guard: hibernated ${count} tabs in late window ${windowId}`) +} diff --git a/src/background/lifecycle/onInstalled.ts b/src/background/lifecycle/onInstalled.ts new file mode 100644 index 0000000..0ed9788 --- /dev/null +++ b/src/background/lifecycle/onInstalled.ts @@ -0,0 +1,66 @@ +import { browser } from '@/shared/browser' +import { sessionsStorage } from '@/shared/storage' +import { shouldRestoreFromSync, restoreFromSync, backupSession } from '@/shared/syncBackup' +import { recoverySnapshotSync, recoverySnapshotsStorage } from '../recovery' + +/** + * Handle extension install/update lifecycle events. + */ +export async function handleInstalled(details: chrome.runtime.InstalledDetails): Promise { + console.log('[Raft] Extension installed/updated:', details.reason) + + if (details.reason === 'install') { + // Check if we should restore sessions from sync (cross-device scenario) + // Note: This works when installing on a new device with the same Chrome profile. + // Sync storage does NOT survive uninstall, so this won't restore after reinstall. + const localSessions = await sessionsStorage.getAll() + if (await shouldRestoreFromSync(localSessions.length)) { + console.log('[Raft] Found sync backup from another device, restoring sessions...') + const restoredSessions = await restoreFromSync() + + for (const session of restoredSessions) { + await sessionsStorage.save(session) + } + + console.log(`[Raft] Restored ${restoredSessions.length} sessions from sync backup`) + } + + // Check if we should restore recovery snapshot from sync (cross-device scenario) + const localSnapshots = await recoverySnapshotsStorage.getAll() + if (localSnapshots.length === 0) { + const syncedSnapshot = await recoverySnapshotSync.get() + if (syncedSnapshot) { + await recoverySnapshotsStorage.save(syncedSnapshot) + console.log( + `[Raft] Restored recovery snapshot from sync (${syncedSnapshot.stats.tabCount} tabs)` + ) + } + } + + // Open onboarding page for new users + const onboardingUrl = browser.runtime.getURL('src/onboarding/index.html') + browser.tabs.create({ url: onboardingUrl }) + } else if (details.reason === 'update') { + console.log('[Raft] Updated from version:', details.previousVersion) + + // Migration: Remove old live backup session (replaced by recovery snapshots) + try { + await sessionsStorage.delete('raft:live-backup') + console.log('[Raft] Migrated: removed old live backup session') + } catch { + // Ignore if doesn't exist + } + + // On update, ensure existing sessions are backed up to sync + // This helps users who upgrade from before sync was added + const sessions = await sessionsStorage.getAll() + const manualSessions = sessions.filter((s) => s.source !== 'auto' && s.source !== 'backup') + + // Backup up to 10 most recent manual sessions (to not overwhelm sync) + const toBackup = manualSessions.sort((a, b) => b.createdAt - a.createdAt).slice(0, 10) + + for (const session of toBackup) { + await backupSession(session) + } + } +} diff --git a/src/background/lifecycle/onStartup.ts b/src/background/lifecycle/onStartup.ts new file mode 100644 index 0000000..600abd1 --- /dev/null +++ b/src/background/lifecycle/onStartup.ts @@ -0,0 +1,68 @@ +import { browser } from '@/shared/browser' +import { settingsStorage } from '@/shared/storage' +import { + SESSION_KEYS, + HIBERNATION_GUARD_DURATION_MS, + PROTECTED_URL_PATTERNS, +} from '@/shared/constants' +import { suspendOtherTabs } from '../suspension' + +/** + * Handle browser startup — hibernate all tabs if the setting is enabled. + */ +export async function handleStartup(): Promise { + const settings = await settingsStorage.get() + if (!settings.suspension.hibernateOnStartup) return + + console.log('[Raft] Hibernate on startup enabled, suspending all tabs') + const allWindows = await browser.windows.getAll() + const windows = allWindows.filter((w) => w.type === 'normal') + const extensionOrigin = browser.runtime.getURL('') + const hibernateTabIds: number[] = [] + + for (const win of windows) { + if (!win.id) continue + // We need a Raft extension page as the active tab so browser.tabs.discard() + // can suspend the user's previously-active tab. Reuse one if already open. + const winTabs = await browser.tabs.query({ windowId: win.id }) + const raftTab = winTabs.find((t) => t.url?.startsWith(extensionOrigin)) + if (raftTab?.id) { + await browser.tabs.update(raftTab.id, { active: true }) + } else { + await browser.tabs.create({ + url: browser.runtime.getURL('src/options/index.html#sessions'), + active: true, + windowId: win.id, + }) + } + + // Record all non-active, non-protected tabs for the hibernation guard + for (const t of winTabs) { + if ( + t.id && + !t.active && + t.url && + !t.url.startsWith(extensionOrigin) && + !PROTECTED_URL_PATTERNS.some((p) => t.url!.startsWith(p)) + ) { + hibernateTabIds.push(t.id) + } + } + + const count = await suspendOtherTabs(win.id) + console.log(`[Raft] Hibernated ${count} tabs in window ${win.id}`) + } + + // Guard catches tabs that couldn't be discarded yet (no main frame), + // tabs Chrome's startup loader undiscards, and normal windows that + // appear after onStartup (e.g., PWA started Chrome first) + await browser.storage.session.set({ + [SESSION_KEYS.HIBERNATION_GUARD]: { + expiresAt: Date.now() + HIBERNATION_GUARD_DURATION_MS, + tabIds: hibernateTabIds, + }, + }) + console.log( + `[Raft] Hibernation guard set for ${hibernateTabIds.length} tabs (${HIBERNATION_GUARD_DURATION_MS / 1000}s window)` + ) +} diff --git a/src/background/listeners.ts b/src/background/listeners.ts new file mode 100644 index 0000000..e2e184c --- /dev/null +++ b/src/background/listeners.ts @@ -0,0 +1,178 @@ +/** + * Listener bodies for the service worker. + * + * The registrations themselves live in src/background/index.ts at module top + * level (required by MV3 to catch wake-up events). These helpers carry the + * logic each listener runs. + */ + +import { browser } from '@/shared/browser' +import { settingsStorage, tabActivityStorage } from '@/shared/storage' +import { ALARM_NAMES } from '@/shared/constants' +import { syncEngine, syncStateStorage } from '@/shared/cloudSync' +import { suspendTab, suspendOtherTabs, checkForInactiveTabs } from './suspension' +import { captureRecoverySnapshot, debouncedCaptureSnapshot } from './recovery' +import { captureCurrentSession, saveSession, performAutoSave } from './sessions' +import { closeDuplicates } from './deduplication' +import { initReady, savePreviousActiveTabs, previousActiveTab } from './state' +import { updateBadge } from './badge' +import { maybeHibernateTab, hibernateWindow } from './lifecycle/hibernation' +import { checkExportReminder } from './messages/exportReminder' +import { handleMessage } from './messages' +import type { MessageType } from './messages' + +export async function handleAlarm(alarm: chrome.alarms.Alarm): Promise { + switch (alarm.name) { + case ALARM_NAMES.SUSPENSION_CHECK: { + await checkForInactiveTabs() + await updateBadge() + const tabs = await browser.tabs.query({}) + const tabIds = new Set(tabs.map((t) => t.id).filter((id): id is number => id !== undefined)) + await tabActivityStorage.cleanup(tabIds) + break + } + case ALARM_NAMES.AUTO_SAVE: + await performAutoSave() + break + case ALARM_NAMES.CLOUD_SYNC: + if ((await syncEngine.isConfigured()) && syncEngine.isUnlocked()) { + const syncState = await syncStateStorage.get() + if (!syncState.authExpired) { + await syncEngine.performFullSync() + } + } + break + case ALARM_NAMES.RECOVERY_SNAPSHOT: + await captureRecoverySnapshot() + break + case ALARM_NAMES.EXPORT_REMINDER: + await checkExportReminder() + break + } +} + +export async function handleTabActivated(activeInfo: chrome.tabs.OnActivatedInfo): Promise { + await initReady + // Touch the tab the user just left so its idle clock starts ticking. + const prevTabId = previousActiveTab.get(activeInfo.windowId) + if (prevTabId !== undefined) { + await tabActivityStorage.touch(prevTabId) + } + previousActiveTab.set(activeInfo.windowId, activeInfo.tabId) + await savePreviousActiveTabs() + await updateBadge() +} + +export async function handleTabUpdated( + tabId: number, + changeInfo: chrome.tabs.OnUpdatedInfo +): Promise { + if (changeInfo.status === 'complete' || changeInfo.discarded === false) { + await maybeHibernateTab(tabId) + } + if (changeInfo.status === 'complete') { + await tabActivityStorage.touch(tabId) + } + if (changeInfo.discarded !== undefined) { + await updateBadge() + debouncedCaptureSnapshot() + } + if (changeInfo.url !== undefined) { + await updateBadge() + } +} + +export async function handleTabRemoved(tabId: number): Promise { + await tabActivityStorage.remove(tabId) + await updateBadge() +} + +export async function handleWindowCreated(win: chrome.windows.Window): Promise { + if (win.type !== 'normal' || !win.id) return + await initReady + + const settings = await settingsStorage.get() + if (!settings.suspension.hibernateOnStartup) return + + // Only hibernate the FIRST normal window — effectively a "startup" (e.g., + // PWA kept Chrome alive, then the user opens a browser window). If other + // normal windows already exist, this is just a new window (Ctrl+N). + const normalWindows = await browser.windows.getAll() + const normalCount = normalWindows.filter((w) => w.type === 'normal').length + if (normalCount > 1) return + + // Small delay to let Chrome finish creating/restoring tabs in the window + await new Promise((resolve) => setTimeout(resolve, 500)) + console.log(`[Raft] First normal window detected (${win.id}), hibernating...`) + await hibernateWindow(win.id) +} + +export async function handleWindowRemoved(windowId: number): Promise { + await initReady + previousActiveTab.delete(windowId) + await savePreviousActiveTabs() +} + +export async function handleContextMenuClick( + info: chrome.contextMenus.OnClickData, + tab: chrome.tabs.Tab | undefined +): Promise { + if (!tab?.id) return + switch (info.menuItemId) { + case 'suspend-tab': + await suspendTab(tab.id) + await updateBadge() + break + case 'suspend-other-tabs': + await suspendOtherTabs(tab.windowId) + await updateBadge() + break + } +} + +export function handleRuntimeMessage( + message: MessageType, + sender: chrome.runtime.MessageSender, + sendResponse: (response: unknown) => void +): boolean { + if (sender.id !== browser.runtime.id) { + sendResponse({ success: false, error: 'Unauthorized sender' }) + return true + } + handleMessage(message) + .then(sendResponse) + .catch((err) => { + console.error('[Raft] Message handler error:', err) + sendResponse({ success: false, error: String(err) }) + }) + return true // Keep channel open for async response +} + +export async function handleCommand(command: string): Promise { + switch (command) { + case 'suspend-current-tab': { + const [tab] = await browser.tabs.query({ active: true, currentWindow: true }) + if (tab?.id) { + await suspendTab(tab.id) + await updateBadge() + } + break + } + case 'suspend-other-tabs': { + const window = await browser.windows.getCurrent() + await suspendOtherTabs(window.id) + await updateBadge() + break + } + case 'close-duplicates': { + await closeDuplicates() + await updateBadge() + break + } + case 'save-session': { + const session = await captureCurrentSession(undefined, 'manual') + await saveSession(session) + break + } + } +} diff --git a/src/background/messages/backupHealth.ts b/src/background/messages/backupHealth.ts new file mode 100644 index 0000000..f6ea849 --- /dev/null +++ b/src/background/messages/backupHealth.ts @@ -0,0 +1,57 @@ +import { settingsStorage } from '@/shared/storage' +import { computeBackupHealth } from '@/shared/backupHealth' +import { syncEngine } from '@/shared/cloudSync' +import { getSyncStatus } from '@/shared/syncBackup' +import { isProUser } from '@/shared/licensing' +import { getAllSessions } from '../sessions' +import { getRecoverySnapshots } from '../recovery' +import type { MessageResponse, MessageType } from './types' + +type BackupHealthMessage = Extract + +export async function handleBackupHealthMessage( + _message: BackupHealthMessage +): Promise { + const [allSessions, healthSettings, browserSyncStatus, cloudStatus, snapshots, isPro] = + await Promise.all([ + getAllSessions(), + settingsStorage.get(), + getSyncStatus(), + syncEngine.getSyncStatus(), + getRecoverySnapshots(), + isProUser(), + ]) + + // Derive lastAutoSaveAt from most recent auto-save session + const autoSaves = allSessions + .filter((s) => s.source === 'auto') + .sort((a, b) => b.createdAt - a.createdAt) + const lastAutoSaveAt = autoSaves.length > 0 ? autoSaves[0].createdAt : undefined + + const healthInput = { + totalSessions: allSessions.length, + autoSaveEnabled: healthSettings.autoSave.enabled, + lastAutoSaveAt, + recoverySnapshotCount: snapshots.length, + lastRecoveryAt: snapshots.length > 0 ? snapshots[0].timestamp : undefined, + browserSync: { + sessionCount: browserSyncStatus.sessionCount, + totalBytes: browserSyncStatus.totalBytes, + maxBytes: browserSyncStatus.maxBytes, + percentUsed: browserSyncStatus.percentUsed, + }, + cloudSync: { + configured: cloudStatus.configured, + enabled: cloudStatus.enabled, + unlocked: cloudStatus.unlocked, + lastSyncAt: cloudStatus.lastSyncAt, + lastError: cloudStatus.lastError, + syncing: cloudStatus.syncing, + }, + isPro, + exportReminderLastExport: healthSettings.exportReminder.lastExportDate, + } + + const health = computeBackupHealth(healthInput) + return { success: true, data: health } +} diff --git a/src/background/messages/cloud.ts b/src/background/messages/cloud.ts new file mode 100644 index 0000000..e1d3edf --- /dev/null +++ b/src/background/messages/cloud.ts @@ -0,0 +1,434 @@ +import { browser } from '@/shared/browser' +import { sessionsStorage } from '@/shared/storage' +import { ALARM_NAMES, CLOUD_SYNC_KEYS } from '@/shared/constants' +import { restoreFromSync, getSyncStatus, clearSyncData } from '@/shared/syncBackup' +import { + syncEngine, + gdrive, + cloudSyncSettingsStorage, + cloudCredentialsStorage, + encryptionKeyStorage, + syncStateStorage, + clearAllCloudSyncData, + launchGoogleOAuth, + setupEncryption, + encryptObject, + decryptObject, + revokeAccess, + deriveKey, + deriveKeyFromRecovery, + generateRecoveryKey, + generateSalt, + createVerificationHash, +} from '@/shared/cloudSync' +import type { CloudTokens, EncryptedPayload } from '@/shared/cloudSync' +import { canUseCloudSync } from '@/shared/licensing' +import { setupCloudSyncAlarm } from '../alarms' +import type { MessageResponse, MessageType } from './types' + +// The browser-sync messages share little with cloud sync mechanically (one +// uses chrome.storage.sync, the other Google Drive), but they're both +// "remote backup" message groups, so they live together. +type CloudMessage = Extract< + MessageType, + { + type: + | 'CLOUD_CONNECT' + | 'CLOUD_DISCONNECT' + | 'CLOUD_RECONNECT' + | 'CLOUD_SETUP_ENCRYPTION' + | 'CLOUD_UNLOCK' + | 'CLOUD_REGENERATE_RECOVERY_KEY' + | 'CLOUD_RECOVER_WITH_KEY' + | 'CLOUD_LOCK' + | 'CLOUD_SYNC' + | 'CLOUD_GET_STATUS' + | 'CLOUD_GET_SETTINGS' + | 'CLOUD_UPDATE_SETTINGS' + | 'CLOUD_GET_SYNCED_IDS' + | 'GET_SYNC_STATUS' + | 'RESTORE_FROM_SYNC' + | 'CLEAR_SYNC_DATA' + } +> + +export async function handleCloudMessage(message: CloudMessage): Promise { + switch (message.type) { + case 'CLOUD_CONNECT': { + // Check Pro status first + if (!(await canUseCloudSync())) { + return { success: false, error: 'Cloud sync requires Pro. Please upgrade.' } + } + + // Launch OAuth flow and get tokens + const result = await launchGoogleOAuth() + + // Tier 1: Check if encryption key data exists locally + const existingKeyData = await encryptionKeyStorage.get() + if (existingKeyData) { + return { + success: true, + data: { + needsUnlock: true, + email: result.email, + tokens: result.tokens, + }, + } + } + + // Tier 2: No local data — check Drive for key data from a previous install + try { + const driveKeyData = await gdrive.downloadKeyData(result.tokens.accessToken) + if (driveKeyData) { + // Restore key data locally so unlock flow works + await encryptionKeyStorage.save({ + salt: driveKeyData.salt, + verificationHash: driveKeyData.verificationHash, + }) + return { + success: true, + data: { + needsUnlock: true, + email: result.email, + tokens: result.tokens, + }, + } + } + } catch (err) { + // Drive failure is non-fatal — fall through to new setup + console.warn('[Raft] Failed to check Drive for existing key data:', err) + } + + // Tier 3: No data anywhere — truly new user + return { + success: true, + data: { + needsEncryptionSetup: true, + email: result.email, + tokens: result.tokens, + }, + } + } + + case 'CLOUD_SETUP_ENCRYPTION': { + // Set up encryption with user's password + const { keyData, recoveryKey, key } = await setupEncryption(message.password) + + // Get tokens from message parameter (passed directly from UI, never stored in plaintext) + const pendingTokens = message.tokens + const pendingEmail = message.email + if (!pendingTokens || !pendingEmail) { + return { success: false, error: 'No pending connection. Please reconnect.' } + } + + // Encrypt and save tokens + const encryptedTokens = await encryptObject(pendingTokens, key) + await cloudCredentialsStorage.save({ + provider: 'gdrive', + encryptedTokens: JSON.stringify(encryptedTokens), + email: pendingEmail, + connectedAt: Date.now(), + }) + + // Also encrypt tokens with recovery key for actual recovery support + const recoveryDerivedKey = await deriveKeyFromRecovery(recoveryKey, keyData.salt) + const recoveryEncrypted = await encryptObject(pendingTokens, recoveryDerivedKey) + keyData.recoveryPayload = JSON.stringify(recoveryEncrypted) + + // Save key data (includes recovery payload) + await encryptionKeyStorage.save(keyData) + + // Upload key data to Drive for future reinstall detection (non-fatal) + try { + await gdrive.uploadKeyData(pendingTokens.accessToken, { + salt: keyData.salt, + verificationHash: keyData.verificationHash, + }) + } catch (err) { + console.warn('[Raft] Failed to upload key data to Drive:', err) + } + + // Enable cloud sync + await cloudSyncSettingsStorage.update({ enabled: true }) + + // Set up sync alarm + const syncSettings = await cloudSyncSettingsStorage.get() + await setupCloudSyncAlarm(syncSettings.intervalMinutes) + + return { + success: true, + data: { recoveryKey }, + } + } + + case 'CLOUD_UNLOCK': { + const unlocked = await syncEngine.unlock(message.password) + if (!unlocked) { + return { success: false, error: 'Incorrect password' } + } + + // If tokens were passed (from a new connect flow), encrypt and save them + if (message.tokens && message.email) { + const unlockKey = syncEngine.getEncryptionKeyForSetup() + if (unlockKey) { + const encryptedTokens = await encryptObject(message.tokens, unlockKey) + await cloudCredentialsStorage.save({ + provider: 'gdrive', + encryptedTokens: JSON.stringify(encryptedTokens), + email: message.email, + connectedAt: Date.now(), + }) + + // Enable cloud sync + await cloudSyncSettingsStorage.update({ enabled: true }) + const syncSettings = await cloudSyncSettingsStorage.get() + await setupCloudSyncAlarm(syncSettings.intervalMinutes) + } + } + + // Process any pending queue items + await syncEngine.processQueue() + + return { success: true } + } + + case 'CLOUD_LOCK': { + syncEngine.lock() + return { success: true } + } + + case 'CLOUD_REGENERATE_RECOVERY_KEY': { + const keyData = await encryptionKeyStorage.get() + if (!keyData) { + return { success: false, error: 'Encryption not set up' } + } + + // Verify password + const key = await deriveKey(message.password, keyData.salt) + const hash = await createVerificationHash(key, keyData.salt) + if (hash !== keyData.verificationHash) { + return { success: false, error: 'Incorrect password' } + } + + // Decrypt tokens with password key + const credentials = await cloudCredentialsStorage.get() + if (!credentials) { + return { success: false, error: 'No cloud credentials found' } + } + const payload = JSON.parse(credentials.encryptedTokens) + const tokens = await decryptObject(payload, key) + + // Generate new recovery key and encrypt tokens with it + const newRecoveryKey = generateRecoveryKey() + const recoveryDerivedKey = await deriveKeyFromRecovery(newRecoveryKey, keyData.salt) + const recoveryEncrypted = await encryptObject(tokens, recoveryDerivedKey) + + // Save updated key data with new recovery payload + await encryptionKeyStorage.save({ + ...keyData, + recoveryPayload: JSON.stringify(recoveryEncrypted), + }) + + return { success: true, data: { recoveryKey: newRecoveryKey } } + } + + case 'CLOUD_RECOVER_WITH_KEY': { + // Recovery flow: verify identity via recovery key, set new password, wipe & re-sync + const keyData = await encryptionKeyStorage.get() + if (!keyData || !keyData.recoveryPayload) { + return { success: false, error: 'No recovery data available' } + } + + // Step 1: Validate recovery key by decrypting the recovery payload + let tokens: CloudTokens + try { + const recoveryDerivedKey = await deriveKeyFromRecovery(message.recoveryKey, keyData.salt) + const recoveryPayload = JSON.parse(keyData.recoveryPayload) as EncryptedPayload + tokens = await decryptObject(recoveryPayload, recoveryDerivedKey) + } catch { + return { success: false, error: 'Invalid recovery key' } + } + + // Step 2: Derive new encryption key from new password with a fresh salt + const newSalt = generateSalt() + const newKey = await deriveKey(message.newPassword, newSalt) + const newVerificationHash = await createVerificationHash(newKey, newSalt) + + // Step 3: Encrypt tokens with the new key + const newEncryptedTokens = await encryptObject(tokens, newKey) + + // Step 4: Generate new recovery key + recovery payload + const newRecoveryKey = generateRecoveryKey() + const newRecoveryDerivedKey = await deriveKeyFromRecovery(newRecoveryKey, newSalt) + const newRecoveryEncrypted = await encryptObject(tokens, newRecoveryDerivedKey) + + // Step 5: Save updated encryption key data + await encryptionKeyStorage.save({ + salt: newSalt, + verificationHash: newVerificationHash, + recoveryPayload: JSON.stringify(newRecoveryEncrypted), + }) + + // Step 6: Save re-encrypted credentials + const credentials = await cloudCredentialsStorage.get() + if (credentials) { + await cloudCredentialsStorage.save({ + ...credentials, + encryptedTokens: JSON.stringify(newEncryptedTokens), + }) + } + + // Step 7: Unlock sync engine with new key + syncEngine.setEncryptionKey(newKey) + + // Step 8: Wipe old encrypted data from Drive & upload new key metadata + try { + await gdrive.clearAllData(tokens.accessToken) + await gdrive.uploadKeyData(tokens.accessToken, { + salt: newSalt, + verificationHash: newVerificationHash, + }) + } catch (err) { + console.warn('[Raft] Recovery: failed to reset Drive data:', err) + } + + // Step 9: Re-upload all local sessions with new encryption (fire-and-forget) + syncEngine.performFullSync().catch((err: unknown) => { + console.error('[Raft] Recovery: post-recovery sync failed:', err) + }) + + return { success: true, data: { recoveryKey: newRecoveryKey } } + } + + case 'CLOUD_DISCONNECT': { + // If unlocked, we can revoke tokens and optionally delete cloud data + if (syncEngine.isUnlocked()) { + try { + const tokens = await syncEngine.getValidTokensForDisconnect() + if (tokens) { + // Delete cloud data if requested + if (message.deleteCloudData) { + await gdrive.clearAllData(tokens.accessToken) + } + // Revoke OAuth access (best-effort) + try { + await revokeAccess(tokens.accessToken) + } catch { + // User might have already revoked in Google settings + } + } + } catch { + // Don't block disconnect on cleanup errors + } + } + + // Clear all local cloud sync data + await clearAllCloudSyncData() + + // Cancel sync alarm + await browser.alarms.clear(ALARM_NAMES.CLOUD_SYNC) + + return { success: true } + } + + case 'CLOUD_RECONNECT': { + if (!(await syncEngine.isConfigured())) { + return { success: false, error: 'Cloud sync not configured' } + } + if (!syncEngine.isUnlocked()) { + return { success: false, error: 'Cloud sync is locked' } + } + + // Launch fresh OAuth flow + const reconnectResult = await launchGoogleOAuth() + + // Encrypt new tokens with existing encryption key + const reconnectKey = syncEngine.getEncryptionKeyForSetup() + if (!reconnectKey) { + return { success: false, error: 'Encryption key not available' } + } + + const reconnectEncrypted = await encryptObject(reconnectResult.tokens, reconnectKey) + + // Save new credentials, preserving existing connectedAt + const existingCreds = await cloudCredentialsStorage.get() + await cloudCredentialsStorage.save({ + provider: 'gdrive', + encryptedTokens: JSON.stringify(reconnectEncrypted), + email: reconnectResult.email, + connectedAt: existingCreds?.connectedAt ?? Date.now(), + }) + + // Clear cached tokens so sync engine picks up new ones + syncEngine.clearCachedTokens() + + // Clear auth error state + await syncStateStorage.update({ authExpired: false, lastError: undefined }) + + return { success: true, data: { email: reconnectResult.email } } + } + + case 'CLOUD_SYNC': { + if (!(await syncEngine.isConfigured())) { + return { success: false, error: 'Cloud sync not configured' } + } + if (!syncEngine.isUnlocked()) { + return { success: false, error: 'Cloud sync is locked' } + } + + const result = await syncEngine.performFullSync() + if (result.success) { + return { success: true, data: result } + } else { + return { success: false, error: result.errors[0] || 'Sync failed' } + } + } + + case 'CLOUD_GET_STATUS': { + const status = await syncEngine.getSyncStatus() + return { success: true, data: status } + } + + case 'CLOUD_GET_SETTINGS': { + const settings = await cloudSyncSettingsStorage.get() + return { success: true, data: settings } + } + + case 'CLOUD_UPDATE_SETTINGS': { + const settings = await cloudSyncSettingsStorage.update(message.settings) + + // Update sync alarm if interval changed + if (settings.enabled) { + await setupCloudSyncAlarm(settings.intervalMinutes) + } else { + await browser.alarms.clear(ALARM_NAMES.CLOUD_SYNC) + } + + return { success: true, data: settings } + } + + case 'CLOUD_GET_SYNCED_IDS': { + const result = await browser.storage.local.get(CLOUD_SYNC_KEYS.SYNCED_IDS) + const ids = (result[CLOUD_SYNC_KEYS.SYNCED_IDS] as string[] | undefined) ?? [] + return { success: true, data: ids } + } + + case 'GET_SYNC_STATUS': { + const status = await getSyncStatus() + return { success: true, data: status } + } + + case 'RESTORE_FROM_SYNC': { + const restoredSessions = await restoreFromSync() + for (const session of restoredSessions) { + await sessionsStorage.save(session) + } + return { success: true, data: { count: restoredSessions.length } } + } + + case 'CLEAR_SYNC_DATA': { + await clearSyncData() + return { success: true } + } + } +} diff --git a/src/background/messages/dedup.ts b/src/background/messages/dedup.ts new file mode 100644 index 0000000..ac83a49 --- /dev/null +++ b/src/background/messages/dedup.ts @@ -0,0 +1,20 @@ +import { getDuplicateCount, closeDuplicates } from '../deduplication' +import { updateBadge } from '../badge' +import type { MessageResponse, MessageType } from './types' + +type DedupMessage = Extract + +export async function handleDedupMessage(message: DedupMessage): Promise { + switch (message.type) { + case 'GET_DUPLICATE_COUNT': { + const count = await getDuplicateCount() + return { success: true, data: { count } } + } + + case 'CLOSE_DUPLICATES': { + const result = await closeDuplicates() + await updateBadge() + return { success: true, data: result } + } + } +} diff --git a/src/background/messages/devtools.ts b/src/background/messages/devtools.ts new file mode 100644 index 0000000..c1a9d8b --- /dev/null +++ b/src/background/messages/devtools.ts @@ -0,0 +1,149 @@ +import { browser } from '@/shared/browser' +import { storage } from '@/shared/storage' +import { DEV_TEST_WINDOWS_KEY } from '@/shared/constants' +import type { MessageResponse, MessageType } from './types' + +type DevToolsMessage = Extract< + MessageType, + { + type: 'DEV_CREATE_SCENARIO' | 'DEV_CLEANUP_TEST_WINDOWS' | 'DEV_GET_TEST_WINDOW_IDS' + } +> + +/** + * Get the list of test window IDs, filtering out windows that no longer exist. + */ +async function getTestWindowIds(): Promise { + const windowIds = await storage.get(DEV_TEST_WINDOWS_KEY, []) + const existingWindows = await browser.windows.getAll() + const existingIds = new Set(existingWindows.map((w) => w.id)) + const validIds = windowIds.filter((id) => existingIds.has(id)) + if (validIds.length !== windowIds.length) { + await storage.set(DEV_TEST_WINDOWS_KEY, validIds) + } + return validIds +} + +async function addTestWindowId(windowId: number): Promise { + const windowIds = await getTestWindowIds() + if (!windowIds.includes(windowId)) { + windowIds.push(windowId) + await storage.set(DEV_TEST_WINDOWS_KEY, windowIds) + } +} + +async function createDevScenario( + scenario: import('@/devtools/types').DevScenario +): Promise<{ windowCount: number; tabCount: number }> { + let totalTabs = 0 + + for (const windowSpec of scenario.windows) { + const createdWindow = await browser.windows.create({ + url: 'about:blank', + focused: windowSpec.focused ?? false, + }) + + const windowId = createdWindow?.id + if (windowId === undefined) continue + await addTestWindowId(windowId) + + const initialTabs = await browser.tabs.query({ windowId }) + const blankTabId = initialTabs[0]?.id + + if (windowSpec.tabs) { + for (const tabSpec of windowSpec.tabs) { + await browser.tabs.create({ + windowId, + url: tabSpec.url, + pinned: tabSpec.pinned ?? false, + active: tabSpec.active ?? false, + }) + totalTabs++ + } + } + + if (windowSpec.groups) { + for (const groupSpec of windowSpec.groups) { + const tabIds: number[] = [] + + for (const tabSpec of groupSpec.tabs) { + const tab = await browser.tabs.create({ + windowId, + url: tabSpec.url, + pinned: tabSpec.pinned ?? false, + active: tabSpec.active ?? false, + }) + if (tab.id) { + tabIds.push(tab.id) + totalTabs++ + } + } + + if (tabIds.length > 0) { + const tabIdsForGroup = tabIds as [number, ...number[]] + const groupId = await browser.tabs.group({ + tabIds: tabIdsForGroup, + createProperties: { windowId }, + }) + + await browser.tabGroups.update(groupId, { + title: groupSpec.title, + color: groupSpec.color as browser.tabGroups.Color, + collapsed: groupSpec.collapsed ?? false, + }) + } + } + } + + if (blankTabId) { + try { + await browser.tabs.remove(blankTabId) + } catch { + // Tab may already be closed + } + } + } + + return { windowCount: scenario.windows.length, tabCount: totalTabs } +} + +async function cleanupTestWindows(): Promise<{ closedCount: number }> { + const windowIds = await getTestWindowIds() + let closedCount = 0 + + for (const windowId of windowIds) { + try { + await browser.windows.remove(windowId) + closedCount++ + } catch { + // Window may already be closed + } + } + + await storage.set(DEV_TEST_WINDOWS_KEY, []) + + return { closedCount } +} + +export async function handleDevToolsMessage(message: DevToolsMessage): Promise { + if (!import.meta.env.DEV) { + return { success: false, error: 'Dev tools are only available in development mode' } + } + + switch (message.type) { + case 'DEV_CREATE_SCENARIO': { + const result = await createDevScenario(message.scenario) + return { success: true, data: result } + } + + case 'DEV_CLEANUP_TEST_WINDOWS': { + const result = await cleanupTestWindows() + return { success: true, data: result } + } + + case 'DEV_GET_TEST_WINDOW_IDS': { + const windowIds = await getTestWindowIds() + return { success: true, data: { windowIds } } + } + } +} diff --git a/src/background/messages/exportReminder.ts b/src/background/messages/exportReminder.ts new file mode 100644 index 0000000..dfd40f3 --- /dev/null +++ b/src/background/messages/exportReminder.ts @@ -0,0 +1,116 @@ +import { settingsStorage, sessionsStorage, storage } from '@/shared/storage' +import { STORAGE_KEYS, EXPORT_REMINDER_CONFIG } from '@/shared/constants' +import { isProUser } from '@/shared/licensing' +import type { MessageResponse, MessageType } from './types' + +/** + * Export reminder state stored in local storage. + */ +export interface ExportReminderState { + /** Whether a reminder is currently pending (not dismissed) */ + pending: boolean + /** Reason for the reminder */ + reason: 'time' | 'milestone' + /** For time-based: days since last export */ + daysSinceExport?: number + /** For milestone: the session count milestone reached */ + milestone?: number + /** Timestamp when reminder was triggered */ + triggeredAt: number +} + +/** + * Check if an export reminder should be shown and update the reminder state. + * Invoked from the EXPORT_REMINDER alarm. + */ +export async function checkExportReminder(): Promise { + const settings = await settingsStorage.get() + + if (!settings.exportReminder.enabled) { + return + } + + // Skip for Pro users (they have cloud backup) + if (await isProUser()) { + return + } + + const sessions = await sessionsStorage.getAll() + const sessionCount = sessions.length + + // Check for time-based reminder + const lastExportDate = settings.exportReminder.lastExportDate + if (lastExportDate) { + const daysSinceExport = Math.floor((Date.now() - lastExportDate) / (1000 * 60 * 60 * 24)) + if (daysSinceExport >= settings.exportReminder.intervalDays) { + const state: ExportReminderState = { + pending: true, + reason: 'time', + daysSinceExport, + triggeredAt: Date.now(), + } + await storage.set(STORAGE_KEYS.EXPORT_REMINDER_STATE, state) + return + } + } else if (sessionCount > 0) { + // No export ever done - set initial lastExportDate to now so we don't nag immediately. + // The reminder will trigger after intervalDays from now. + await settingsStorage.update({ + exportReminder: { ...settings.exportReminder, lastExportDate: Date.now() }, + }) + } + + // Check for milestone-based reminder + const lastMilestone = settings.exportReminder.lastMilestoneReached ?? 0 + for (const milestone of EXPORT_REMINDER_CONFIG.MILESTONES) { + if (sessionCount >= milestone && milestone > lastMilestone) { + const state: ExportReminderState = { + pending: true, + reason: 'milestone', + milestone, + triggeredAt: Date.now(), + } + await storage.set(STORAGE_KEYS.EXPORT_REMINDER_STATE, state) + // Update the last milestone so we don't trigger again for the same milestone + await settingsStorage.update({ + exportReminder: { ...settings.exportReminder, lastMilestoneReached: milestone }, + }) + return + } + } +} + +type ExportReminderMessage = Extract< + MessageType, + { + type: 'GET_EXPORT_REMINDER_STATE' | 'DISMISS_EXPORT_REMINDER' | 'MARK_EXPORT_COMPLETE' + } +> + +export async function handleExportReminderMessage( + message: ExportReminderMessage +): Promise { + switch (message.type) { + case 'GET_EXPORT_REMINDER_STATE': { + const state = await storage.get( + STORAGE_KEYS.EXPORT_REMINDER_STATE, + null + ) + return { success: true, data: state } + } + + case 'DISMISS_EXPORT_REMINDER': { + await storage.remove(STORAGE_KEYS.EXPORT_REMINDER_STATE) + return { success: true } + } + + case 'MARK_EXPORT_COMPLETE': { + const settings = await settingsStorage.get() + await settingsStorage.update({ + exportReminder: { ...settings.exportReminder, lastExportDate: Date.now() }, + }) + await storage.remove(STORAGE_KEYS.EXPORT_REMINDER_STATE) + return { success: true } + } + } +} diff --git a/src/background/messages/index.ts b/src/background/messages/index.ts new file mode 100644 index 0000000..7d643ce --- /dev/null +++ b/src/background/messages/index.ts @@ -0,0 +1,97 @@ +import type { MessageResponse, MessageType } from './types' +import { handleSuspensionMessage } from './suspension' +import { handleSessionsMessage } from './sessions' +import { handleCloudMessage } from './cloud' +import { handleProMessage } from './pro' +import { handleRecoveryMessage } from './recovery' +import { handleExportReminderMessage } from './exportReminder' +import { handleDedupMessage } from './dedup' +import { handleBackupHealthMessage } from './backupHealth' +import { handleDevToolsMessage } from './devtools' + +export type { MessageType, MessageResponse } from './types' + +/** + * Process incoming messages by routing each MessageType to its domain handler. + */ +export async function handleMessage(message: MessageType): Promise { + try { + switch (message.type) { + case 'SUSPEND_TAB': + case 'SUSPEND_OTHER_TABS': + case 'SUSPEND_ALL_TABS': + case 'RESTORE_ALL_TABS': + case 'GET_TAB_COUNTS': + case 'GET_CURRENT_TAB_STATUS': + case 'GET_SETTINGS': + case 'UPDATE_SETTINGS': + return await handleSuspensionMessage(message) + + case 'SAVE_SESSION': + case 'SAVE_WINDOW': + case 'RESTORE_SESSION': + case 'GET_SESSIONS': + case 'DELETE_SESSION': + case 'RENAME_SESSION': + case 'SEARCH_SESSIONS': + case 'RESTORE_SESSION_PARTIAL': + return await handleSessionsMessage(message) + + case 'CLOUD_CONNECT': + case 'CLOUD_DISCONNECT': + case 'CLOUD_RECONNECT': + case 'CLOUD_SETUP_ENCRYPTION': + case 'CLOUD_UNLOCK': + case 'CLOUD_REGENERATE_RECOVERY_KEY': + case 'CLOUD_RECOVER_WITH_KEY': + case 'CLOUD_LOCK': + case 'CLOUD_SYNC': + case 'CLOUD_GET_STATUS': + case 'CLOUD_GET_SETTINGS': + case 'CLOUD_UPDATE_SETTINGS': + case 'CLOUD_GET_SYNCED_IDS': + case 'GET_SYNC_STATUS': + case 'RESTORE_FROM_SYNC': + case 'CLEAR_SYNC_DATA': + return await handleCloudMessage(message) + + case 'PRO_CHECK_STATUS': + case 'PRO_OPEN_CHECKOUT': + case 'PRO_ACTIVATE_LICENSE': + case 'PRO_GET_LICENSE': + case 'PRO_CLEAR_LICENSE': + return await handleProMessage(message) + + case 'GET_RECOVERY_SNAPSHOTS': + case 'RESTORE_RECOVERY_SNAPSHOT': + case 'DELETE_RECOVERY_SNAPSHOT': + return await handleRecoveryMessage(message) + + case 'GET_EXPORT_REMINDER_STATE': + case 'DISMISS_EXPORT_REMINDER': + case 'MARK_EXPORT_COMPLETE': + return await handleExportReminderMessage(message) + + case 'GET_DUPLICATE_COUNT': + case 'CLOSE_DUPLICATES': + return await handleDedupMessage(message) + + case 'GET_BACKUP_HEALTH': + return await handleBackupHealthMessage(message) + + case 'DEV_CREATE_SCENARIO': + case 'DEV_CLEANUP_TEST_WINDOWS': + case 'DEV_GET_TEST_WINDOW_IDS': + return await handleDevToolsMessage(message) + + default: { + const _exhaustive: never = message + void _exhaustive + return { success: false, error: 'Unknown message type' } + } + } + } catch (error) { + console.error('[Raft] Message handler error:', error) + return { success: false, error: String(error) } + } +} diff --git a/src/background/messages/pro.ts b/src/background/messages/pro.ts new file mode 100644 index 0000000..f492eca --- /dev/null +++ b/src/background/messages/pro.ts @@ -0,0 +1,54 @@ +import { + checkLicense, + openCheckoutPage, + activateLicense, + getStoredLicense, + clearLicense, + isProUser, +} from '@/shared/licensing' +import type { MessageResponse, MessageType } from './types' + +type ProMessage = Extract< + MessageType, + { + type: + | 'PRO_CHECK_STATUS' + | 'PRO_OPEN_CHECKOUT' + | 'PRO_ACTIVATE_LICENSE' + | 'PRO_GET_LICENSE' + | 'PRO_CLEAR_LICENSE' + } +> + +export async function handleProMessage(message: ProMessage): Promise { + switch (message.type) { + case 'PRO_CHECK_STATUS': { + const isPro = await isProUser() + const { email } = isPro ? await checkLicense() : { email: undefined } + return { success: true, data: { isPro, email } } + } + + case 'PRO_OPEN_CHECKOUT': { + openCheckoutPage() + return { success: true } + } + + case 'PRO_ACTIVATE_LICENSE': { + const license = await activateLicense(message.licenseKey) + if (license && license.status === 'active') { + return { success: true, data: { license } } + } + return { success: false, error: 'Invalid or inactive license key' } + } + + case 'PRO_GET_LICENSE': { + const license = await getStoredLicense() + return { success: true, data: { license } } + } + + case 'PRO_CLEAR_LICENSE': { + await clearLicense() + return { success: true } + } + } +} diff --git a/src/background/messages/recovery.ts b/src/background/messages/recovery.ts new file mode 100644 index 0000000..ff8b98c --- /dev/null +++ b/src/background/messages/recovery.ts @@ -0,0 +1,34 @@ +import { getRecoverySnapshots, restoreFromSnapshot, deleteRecoverySnapshot } from '../recovery' +import type { MessageResponse, MessageType } from './types' + +type RecoveryMessage = Extract< + MessageType, + { + type: 'GET_RECOVERY_SNAPSHOTS' | 'RESTORE_RECOVERY_SNAPSHOT' | 'DELETE_RECOVERY_SNAPSHOT' + } +> + +export async function handleRecoveryMessage(message: RecoveryMessage): Promise { + switch (message.type) { + case 'GET_RECOVERY_SNAPSHOTS': { + const snapshots = await getRecoverySnapshots() + return { success: true, data: snapshots } + } + + case 'RESTORE_RECOVERY_SNAPSHOT': { + const result = await restoreFromSnapshot(message.snapshotId) + if (result) { + return { success: true, data: result } + } + return { success: false, error: 'Failed to restore from snapshot' } + } + + case 'DELETE_RECOVERY_SNAPSHOT': { + const deleted = await deleteRecoverySnapshot(message.snapshotId) + if (deleted) { + return { success: true } + } + return { success: false, error: 'Failed to delete snapshot' } + } + } +} diff --git a/src/background/messages/sessions.ts b/src/background/messages/sessions.ts new file mode 100644 index 0000000..fce81f0 --- /dev/null +++ b/src/background/messages/sessions.ts @@ -0,0 +1,89 @@ +import { + captureCurrentSession, + captureWindow, + restoreSession, + restoreSessionPartial, + saveSession, + deleteSession, + renameSession, + getAllSessions, + searchSessions, + getSessionStats, +} from '../sessions' +import type { MessageResponse, MessageType } from './types' + +type SessionsMessage = Extract< + MessageType, + { + type: + | 'SAVE_SESSION' + | 'SAVE_WINDOW' + | 'RESTORE_SESSION' + | 'GET_SESSIONS' + | 'DELETE_SESSION' + | 'RENAME_SESSION' + | 'SEARCH_SESSIONS' + | 'RESTORE_SESSION_PARTIAL' + } +> + +export async function handleSessionsMessage(message: SessionsMessage): Promise { + switch (message.type) { + case 'SAVE_SESSION': { + const session = await captureCurrentSession(message.name, 'manual') + await saveSession(session) + return { success: true, data: { session, stats: getSessionStats(session) } } + } + + case 'SAVE_WINDOW': { + const session = await captureWindow(message.windowId, message.name) + await saveSession(session) + return { success: true, data: { session, stats: getSessionStats(session) } } + } + + case 'RESTORE_SESSION': { + const result = await restoreSession(message.sessionId, { + asSuspended: message.asSuspended, + }) + return { success: true, data: result } + } + + case 'GET_SESSIONS': { + const sessions = await getAllSessions() + const sessionsWithStats = sessions.map((s) => ({ + ...s, + stats: getSessionStats(s), + })) + sessionsWithStats.sort((a, b) => b.createdAt - a.createdAt) + return { success: true, data: sessionsWithStats } + } + + case 'DELETE_SESSION': { + await deleteSession(message.sessionId) + return { success: true } + } + + case 'RENAME_SESSION': { + await renameSession(message.sessionId, message.name) + return { success: true } + } + + case 'SEARCH_SESSIONS': { + const sessions = await searchSessions(message.query) + const sessionsWithStats = sessions.map((s) => ({ + ...s, + stats: getSessionStats(s), + })) + sessionsWithStats.sort((a, b) => b.createdAt - a.createdAt) + return { success: true, data: sessionsWithStats } + } + + case 'RESTORE_SESSION_PARTIAL': { + const result = await restoreSessionPartial(message.sessionId, { + asSuspended: message.asSuspended, + selection: message.selection, + }) + return { success: true, data: result } + } + } +} diff --git a/src/background/messages/suspension.ts b/src/background/messages/suspension.ts new file mode 100644 index 0000000..8cad810 --- /dev/null +++ b/src/background/messages/suspension.ts @@ -0,0 +1,121 @@ +import { browser } from '@/shared/browser' +import { settingsStorage } from '@/shared/storage' +import { ALARM_NAMES } from '@/shared/constants' +import { + suspendTab, + suspendOtherTabs, + suspendAllTabs, + restoreAllTabs, + getTabCounts, + canSuspendTab, +} from '../suspension' +import { updateBadge } from '../badge' +import { setupSuspensionAlarm, setupAutoSaveAlarm, setupExportReminderAlarm } from '../alarms' +import type { MessageResponse, MessageType } from './types' + +type SuspensionMessage = Extract< + MessageType, + { + type: + | 'SUSPEND_TAB' + | 'SUSPEND_OTHER_TABS' + | 'SUSPEND_ALL_TABS' + | 'RESTORE_ALL_TABS' + | 'GET_TAB_COUNTS' + | 'GET_CURRENT_TAB_STATUS' + | 'GET_SETTINGS' + | 'UPDATE_SETTINGS' + } +> + +export async function handleSuspensionMessage( + message: SuspensionMessage +): Promise { + switch (message.type) { + case 'SUSPEND_TAB': { + const suspended = await suspendTab(message.tabId) + await updateBadge() + if (suspended) { + return { success: true, data: { suspended: true } } + } + return { success: false, error: 'Tab could not be suspended' } + } + + case 'SUSPEND_OTHER_TABS': { + const count = await suspendOtherTabs(message.windowId) + await updateBadge() + return { success: true, data: { suspended: count } } + } + + case 'SUSPEND_ALL_TABS': { + const count = await suspendAllTabs() + await updateBadge() + return { success: true, data: { suspended: count } } + } + + case 'RESTORE_ALL_TABS': { + const count = await restoreAllTabs(message.windowId) + await updateBadge() + return { success: true, data: { restored: count } } + } + + case 'GET_TAB_COUNTS': { + const counts = await getTabCounts() + return { success: true, data: counts } + } + + case 'GET_CURRENT_TAB_STATUS': { + const [tab] = await browser.tabs.query({ active: true, currentWindow: true }) + if (!tab) { + return { success: false, error: 'No active tab' } + } + const check = await canSuspendTab(tab) + const suspended = tab.discarded ?? false + return { + success: true, + data: { + tab: { + id: tab.id, + title: tab.title, + url: tab.url, + suspended, + pinned: tab.pinned, + audible: tab.audible, + }, + canSuspend: check.canSuspend, + reason: check.reason, + }, + } + } + + case 'GET_SETTINGS': { + const settings = await settingsStorage.get() + return { success: true, data: settings } + } + + case 'UPDATE_SETTINGS': { + const settings = await settingsStorage.update(message.settings) + + if (settings.suspension.enabled) { + await setupSuspensionAlarm() + } else { + await browser.alarms.clear(ALARM_NAMES.SUSPENSION_CHECK) + } + + if (settings.autoSave.enabled) { + await setupAutoSaveAlarm(settings.autoSave.intervalMinutes) + } else { + await browser.alarms.clear(ALARM_NAMES.AUTO_SAVE) + } + + if (settings.exportReminder.enabled) { + await setupExportReminderAlarm() + } else { + await browser.alarms.clear(ALARM_NAMES.EXPORT_REMINDER) + } + + await updateBadge() + return { success: true, data: settings } + } + } +} diff --git a/src/background/messages/types.ts b/src/background/messages/types.ts new file mode 100644 index 0000000..f99f1b0 --- /dev/null +++ b/src/background/messages/types.ts @@ -0,0 +1,74 @@ +import type { MessageResponse, Settings } from '@/shared/types' +import type { CloudTokens } from '@/shared/cloudSync' + +export type MessageType = + | { type: 'SUSPEND_TAB'; tabId: number } + | { type: 'SUSPEND_OTHER_TABS'; windowId?: number } + | { type: 'SUSPEND_ALL_TABS' } + | { type: 'RESTORE_ALL_TABS'; windowId?: number } + | { type: 'GET_TAB_COUNTS' } + | { type: 'GET_CURRENT_TAB_STATUS' } + | { type: 'GET_SETTINGS' } + | { type: 'UPDATE_SETTINGS'; settings: Partial } + // Session messages + | { type: 'SAVE_SESSION'; name?: string } + | { type: 'SAVE_WINDOW'; windowId: number; name?: string } + | { type: 'RESTORE_SESSION'; sessionId: string; asSuspended?: boolean } + | { type: 'GET_SESSIONS' } + | { type: 'DELETE_SESSION'; sessionId: string } + | { type: 'SEARCH_SESSIONS'; query: string } + // Cloud sync messages + | { type: 'CLOUD_CONNECT' } + | { type: 'CLOUD_DISCONNECT'; deleteCloudData?: boolean } + | { type: 'CLOUD_RECONNECT' } + | { type: 'CLOUD_SETUP_ENCRYPTION'; password: string; tokens?: CloudTokens; email?: string } + | { type: 'CLOUD_UNLOCK'; password: string; tokens?: CloudTokens; email?: string } + | { type: 'CLOUD_REGENERATE_RECOVERY_KEY'; password: string } + | { type: 'CLOUD_RECOVER_WITH_KEY'; recoveryKey: string; newPassword: string } + | { type: 'CLOUD_LOCK' } + | { type: 'CLOUD_SYNC' } + | { type: 'CLOUD_GET_STATUS' } + | { type: 'CLOUD_GET_SETTINGS' } + | { + type: 'CLOUD_UPDATE_SETTINGS' + settings: Partial + } + | { type: 'CLOUD_GET_SYNCED_IDS' } + // Pro licensing messages + | { type: 'PRO_CHECK_STATUS' } + | { type: 'PRO_OPEN_CHECKOUT' } + | { type: 'PRO_ACTIVATE_LICENSE'; licenseKey: string } + | { type: 'PRO_GET_LICENSE' } + | { type: 'PRO_CLEAR_LICENSE' } + // Browser sync status + | { type: 'GET_SYNC_STATUS' } + | { type: 'RESTORE_FROM_SYNC' } + | { type: 'CLEAR_SYNC_DATA' } + // Recovery snapshot messages + | { type: 'GET_RECOVERY_SNAPSHOTS' } + | { type: 'RESTORE_RECOVERY_SNAPSHOT'; snapshotId: string } + | { type: 'DELETE_RECOVERY_SNAPSHOT'; snapshotId: string } + // Export reminder messages + | { type: 'GET_EXPORT_REMINDER_STATE' } + | { type: 'DISMISS_EXPORT_REMINDER' } + | { type: 'MARK_EXPORT_COMPLETE' } + // Session rename + | { type: 'RENAME_SESSION'; sessionId: string; name: string } + // Tab deduplication messages + | { type: 'GET_DUPLICATE_COUNT' } + | { type: 'CLOSE_DUPLICATES' } + // Partial session restore + | { + type: 'RESTORE_SESSION_PARTIAL' + sessionId: string + asSuspended?: boolean + selection: import('@/shared/types').PartialRestoreSelection + } + // Backup health + | { type: 'GET_BACKUP_HEALTH' } + // Dev tools messages (dev mode only) + | { type: 'DEV_CREATE_SCENARIO'; scenario: import('@/devtools/types').DevScenario } + | { type: 'DEV_CLEANUP_TEST_WINDOWS' } + | { type: 'DEV_GET_TEST_WINDOW_IDS' } + +export type { MessageResponse } diff --git a/src/background/state.ts b/src/background/state.ts new file mode 100644 index 0000000..e95c039 --- /dev/null +++ b/src/background/state.ts @@ -0,0 +1,42 @@ +/** + * Background service worker in-memory state. + * + * MV3 service workers terminate after ~30s of inactivity, so anything that + * needs to outlive a single wake must be persisted to browser.storage. + * The maps below are reloaded from storage during initialize(). + */ + +import { storage } from '@/shared/storage' +import { STORAGE_KEYS } from '@/shared/constants' + +// Track previously active tab per window (for activity-on-leave tracking). +// When the user switches away from a tab, we touch it to record the departure +// time. Persisted to browser.storage so it survives service worker restarts. +export const previousActiveTab: Map = new Map() + +// Initialization promise — listeners await this before touching state that +// initialize() populates from storage. +let resolveInit: () => void +export const initReady: Promise = new Promise((resolve) => { + resolveInit = resolve +}) + +export function markInitReady(): void { + resolveInit() +} + +export async function loadPreviousActiveTabs(): Promise { + const stored = await storage.get>(STORAGE_KEYS.PREVIOUS_ACTIVE_TABS, {}) + previousActiveTab.clear() + for (const [windowId, tabId] of Object.entries(stored)) { + previousActiveTab.set(parseInt(windowId, 10), tabId) + } +} + +export async function savePreviousActiveTabs(): Promise { + const obj: Record = {} + for (const [windowId, tabId] of previousActiveTab) { + obj[String(windowId)] = tabId + } + await storage.set(STORAGE_KEYS.PREVIOUS_ACTIVE_TABS, obj) +} diff --git a/vite.config.ts b/vite.config.ts index a0d1728..5208bb9 100644 --- a/vite.config.ts +++ b/vite.config.ts @@ -160,6 +160,13 @@ export default defineConfig(({ mode }) => { 'src/shared/stores/**', // Zustand stores - tested via integration 'src/shared/a11y/**', // Accessibility hooks - tested via E2E 'src/devtools/**', // DevTools scenarios - tested manually + // Background SW glue — these were extracted from src/background/index.ts + // (which is excluded as an entry point) and are exercised end-to-end + // via the suspension/sessions/recovery suites that cover the underlying + // domain modules they delegate to. + 'src/background/listeners.ts', + 'src/background/lifecycle/**', + 'src/background/messages/**', ], thresholds: { statements: 70,