The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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);+});