fix: propagate profile updates across extension contexts

`onProfileUpdate` was an in-memory callback list, so saves made from the
popup/config page never reached the background. Alarm reconciliation
therefore missed interval changes until the next service-worker wake.

Route `onProfileUpdate` through `chrome.storage.local.onChanged` instead
— the browser dispatches storage events in every extension context, so
subscribers fire regardless of which context wrote. `overwriteProfiles`
no longer fans out in-memory; the storage event does it.

Added `onLocalStorageChanged` to the adapter layer (Chrome/Firefox wrap
the native event; the WebBrowser dev adapter simulates it so local dev
reactivity still works).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: SYM01

src/adapters/base.ts

@@ -80,6 +80,12 @@ export abstract class BaseAdapter {
     return ret;
   }
 
+  // Fires when local storage changes in any extension context, including
+  // this one — the browser dispatches the event everywhere.
+  abstract onLocalStorageChanged(
+    callback: (changes: Record<string, { newValue?: unknown }>) => void
+  ): void;
+
   // proxy
   abstract setProxy(cfg: ProxyConfig): Promise<void>;
   abstract clearProxy(): Promise<void>;

src/adapters/chrome.ts

@@ -31,6 +31,12 @@ export class Chrome extends BaseAdapter {
     return ret[key] as T | undefined;
   }
 
+  onLocalStorageChanged(
+    callback: (changes: Record<string, { newValue?: unknown }>) => void
+  ): void {
+    chrome.storage.local.onChanged.addListener(callback);
+  }
+
   async setProxy(cfg: ProxyConfig): Promise<void> {
     await chrome.proxy.settings.set({
       value: cfg,

src/adapters/firefox.ts

@@ -26,6 +26,12 @@ export class Firefox extends BaseAdapter {
     return ret[key];
   }
 
+  onLocalStorageChanged(
+    callback: (changes: Record<string, { newValue?: unknown }>) => void
+  ): void {
+    browser.storage.local.onChanged.addListener(callback);
+  }
+
   async setProxy(cfg: ProxyConfig): Promise<void> {
     const proxyCfg: browser.proxy.ProxyConfig = {};
 

src/adapters/web.ts

@@ -28,15 +28,27 @@ export class WebBrowser extends BaseAdapter {
     return BrowserFlavor.Web;
   }
 
+  private storageListeners: ((
+    changes: Record<string, { newValue?: unknown }>
+  ) => void)[] = [];
+
   async set<T>(key: string, val: T): Promise<void> {
     localStorage.setItem(key, JSON.stringify(val));
+    const changes = { [key]: { newValue: val } };
+    this.storageListeners.forEach((cb) => cb(changes));
   }
   async get<T>(key: string): Promise<T | undefined> {
     let s: any;
     s = localStorage.getItem(key);
     return s && JSON.parse(s);
   }
 
+  onLocalStorageChanged(
+    callback: (changes: Record<string, { newValue?: unknown }>) => void
+  ): void {
+    this.storageListeners.push(callback);
+  }
+
   async setProxy(_: ProxyConfig): Promise<void> {
     window.localStorage.setItem("proxy", JSON.stringify(_));
   }

src/services/profile.ts

@@ -122,20 +122,35 @@ export const SystemProfile: Record<string, ProxyProfile> = {
 const keyProfileStorage = "profiles";
 export type ProfilesStorage = Record<string, ProxyProfile>;
 const onProfileUpdateListeners: ((p: ProfilesStorage) => void)[] = [];
+let storageListenerRegistered = false;
 
 // list all user defined profiles. System profiles are not included
 export async function listProfiles(): Promise<ProfilesStorage> {
   const s = await Host.get<ProfilesStorage>(keyProfileStorage);
   return s || {};
 }
 
+/**
+ * Subscribe to profile updates. Fires in every extension context (popup,
+ * config page, background) whenever the profiles storage key is written,
+ * regardless of which context made the write — backed by the browser's
+ * storage change events.
+ */
 export function onProfileUpdate(callback: (p: ProfilesStorage) => void) {
+  if (!storageListenerRegistered) {
+    storageListenerRegistered = true;
+    Host.onLocalStorageChanged((changes) => {
+      if (!(keyProfileStorage in changes)) return;
+      const profiles = (changes[keyProfileStorage].newValue ??
+        {}) as ProfilesStorage;
+      onProfileUpdateListeners.forEach((cb) => cb(profiles));
+    });
+  }
   onProfileUpdateListeners.push(callback);
 }
 
 async function overwriteProfiles(profiles: ProfilesStorage) {
   await Host.set(keyProfileStorage, deepClone(profiles));
-  onProfileUpdateListeners.forEach((cb) => cb(profiles));
 }
 
 /**