Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

fix(browser-extension): stop rapid settings changes from overwriting each other (#836)

Rudy Mizrahi Celeklie368d0664069
diff --git a/browser-extension/e2e/settings-concurrent.spec.ts b/browser-extension/e2e/settings-concurrent.spec.ts
new file mode 100644
index 00000000..842a7f25
--- /dev/null
+++ b/browser-extension/e2e/settings-concurrent.spec.ts
@@ -0,0 +1,29 @@
+import { test, expect, seedSettings } from './fixtures.js';
+
+test('rapid popup changes preserve both independently edited settings', async ({ context, extensionId, serviceWorker }) => {
+ await seedSettings(serviceWorker, { enabled: false, retention: 'full' });
+ const page = await context.newPage();
+ await page.goto(`chrome-extension://${extensionId}/popup.html`);
+ await expect(page.locator('#endpoint')).toHaveText('http://127.0.0.1:4318/v1/logs');
+ await expect(page.locator('#enabled')).not.toBeChecked();
+ await expect(page.locator('#retention')).toHaveValue('full');
+ await page.evaluate(() => {
+ (window as unknown as { refreshes: number }).refreshes = 0;
+ chrome.storage.onChanged.addListener((changes, area) => {
+ if (area === 'local' && changes.settings) {
+ (window as unknown as { refreshes: number }).refreshes += 1;
+ }
+ });
+ const enabled = document.getElementById('enabled') as HTMLInputElement;
+ const retention = document.getElementById('retention') as HTMLSelectElement;
+ enabled.checked = true;
+ enabled.dispatchEvent(new Event('change', { bubbles: true }));
+ retention.value = 'metadata';
+ retention.dispatchEvent(new Event('change', { bubbles: true }));
+ });
+ await expect.poll(() => page.evaluate(() => (window as unknown as { refreshes: number }).refreshes)).toBeGreaterThanOrEqual(2);
+ await page.reload();
+ await expect(page.locator('#endpoint')).toHaveText('http://127.0.0.1:4318/v1/logs');
+ await expect(page.locator('#enabled')).toBeChecked();
+ await expect(page.locator('#retention')).toHaveValue('metadata');
+});
diff --git a/browser-extension/src/background/delivery.ts b/browser-extension/src/background/delivery.ts
index 5f1320cb..c00ea321 100644
--- a/browser-extension/src/background/delivery.ts
+++ b/browser-extension/src/background/delivery.ts
@@ -9,6 +9,7 @@ import { turnToEnvelope } from '../shared/normalize.js';
import type { LogsEnvelope } from '../shared/otlp.js';
import type { BrowserIdentity } from '../shared/browser-identity.js';
import { isAllowedEndpoint } from '../shared/validate.js';
+import { serial } from '../shared/serial.js';
const QUEUE_KEY = 'delivery_queue';
const ALARM = 'beacon_flush';
@@ -32,19 +33,9 @@ async function writeQueue(items: QueueItem[]): Promise<void> {
await ext.storage.local.set({ [QUEUE_KEY]: items });
}
-// Serialize every read-modify-write on the queue. The service worker is a single
-// JS context, but async interleaving of enqueue/flush would otherwise let two
-// read→write cycles clobber each other's writes (dropping queued telemetry).
-// Only this SW writes QUEUE_KEY, so an in-memory promise-chain mutex suffices.
-let queueLock: Promise<unknown> = Promise.resolve();
-function withQueueLock<T>(fn: () => Promise<T>): Promise<T> {
- const result = queueLock.then(fn, fn);
- queueLock = result.then(
- () => undefined,
- () => undefined,
- );
- return result;
-}
+// Every read-modify-write on the queue goes through here, so enqueue and flush never clobber
+// each other's writes (dropping queued telemetry).
+const withQueueLock = serial();
/** Normalize a turn and enqueue it for delivery, then kick a flush. */
export async function enqueueTurn(
diff --git a/browser-extension/src/background/settings.ts b/browser-extension/src/background/settings.ts
index b8987725..537161da 100644
--- a/browser-extension/src/background/settings.ts
+++ b/browser-extension/src/background/settings.ts
@@ -2,10 +2,13 @@
// survives service-worker suspension.
import { ext } from '../shared/browser.js';
+import { serial } from '../shared/serial.js';
import { DEFAULT_SETTINGS, type Settings, type SiteName } from '../shared/types.js';
import { parseSettingsPatch } from '../shared/validate.js';
const KEY = 'settings';
+// Concurrent popup and options patches must merge over the preceding write, not a stale snapshot.
+const withSettingsLock = serial();
/**
* Merge stored settings over the defaults, keeping only stored values that
@@ -34,15 +37,17 @@ export async function getSettings(): Promise<Settings> {
}
/** Apply an already-validated patch (see parseSettingsPatch). */
-export async function saveSettings(patch: Partial<Settings>): Promise<Settings> {
- const current = await getSettings();
- const next: Settings = {
- ...current,
- ...patch,
- sites: { ...current.sites, ...(patch.sites ?? {}) },
- };
- await ext.storage.local.set({ [KEY]: next });
- return next;
+export function saveSettings(patch: Partial<Settings>): Promise<Settings> {
+ return withSettingsLock(async () => {
+ const current = await getSettings();
+ const next: Settings = {
+ ...current,
+ ...patch,
+ sites: { ...current.sites, ...(patch.sites ?? {}) },
+ };
+ await ext.storage.local.set({ [KEY]: next });
+ return next;
+ });
}
export function siteEnabled(settings: Settings, site: SiteName): boolean {
diff --git a/browser-extension/src/shared/serial.ts b/browser-extension/src/shared/serial.ts
new file mode 100644
index 00000000..dc4f296e
--- /dev/null
+++ b/browser-extension/src/shared/serial.ts
@@ -0,0 +1,18 @@
+// serial returns a runner that executes the functions passed to it one at a time, in call order.
+//
+// The service worker is a single JS context, but two async read-modify-write cycles on the same
+// chrome.storage key interleave at their awaits, and the later write replaces the earlier one with
+// a stale snapshot. Each storage key with a read-modify-write gets its own runner; only this SW
+// writes those keys, so an in-memory promise chain is enough. A rejected function rejects its own
+// caller and does not stop the functions queued after it.
+export function serial(): <T>(fn: () => Promise<T>) => Promise<T> {
+ let tail: Promise<unknown> = Promise.resolve();
+ return (fn) => {
+ const result = tail.then(fn, fn);
+ tail = result.then(
+ () => undefined,
+ () => undefined,
+ );
+ return result;
+ };
+}
diff --git a/browser-extension/test/unit/settings-write.test.ts b/browser-extension/test/unit/settings-write.test.ts
new file mode 100644
index 00000000..1d7b0d6a
--- /dev/null
+++ b/browser-extension/test/unit/settings-write.test.ts
@@ -0,0 +1,30 @@
+import { beforeEach, expect, it, vi } from 'vitest';
+
+const storage = vi.hoisted(() => ({ get: vi.fn(), set: vi.fn() }));
+vi.mock('../../src/shared/browser.js', () => ({ ext: { storage: { local: storage } } }));
+
+beforeEach(() => {
+ vi.resetModules();
+ storage.get.mockReset();
+ storage.set.mockReset();
+});
+
+it('merges concurrent patches against the preceding persisted settings', async () => {
+ let stored = { enabled: false, retention: 'full' };
+ storage.get.mockImplementation(async () => ({ settings: { ...stored } }));
+ storage.set.mockImplementation(async ({ settings }) => { stored = settings; });
+ const { saveSettings } = await import('../../src/background/settings.js');
+ await Promise.all([saveSettings({ enabled: true }), saveSettings({ retention: 'metadata' })]);
+ expect(stored).toMatchObject({ enabled: true, retention: 'metadata' });
+});
+
+it('reports a rejected write and still allows the following save', async () => {
+ storage.get.mockResolvedValue({ settings: { enabled: false } });
+ storage.set.mockRejectedValueOnce(new Error('storage failed')).mockResolvedValueOnce(undefined);
+ const { saveSettings } = await import('../../src/background/settings.js');
+ const first = saveSettings({ enabled: true });
+ const second = saveSettings({ retention: 'metadata' });
+ await expect(first).rejects.toThrow('storage failed');
+ await expect(second).resolves.toMatchObject({ retention: 'metadata' });
+ expect(storage.set).toHaveBeenCalledTimes(2);
+});