Skip to content

The open-source app everyone uses to manage agents at work

fix(ui): bound shared polling cache (#9406)

Dotta07e528256e8a
diff --git a/ui/src/lib/cross-tab-poll.test.ts b/ui/src/lib/cross-tab-poll.test.ts
index 19d5c67c84..31e3d228f7 100644
--- a/ui/src/lib/cross-tab-poll.test.ts
+++ b/ui/src/lib/cross-tab-poll.test.ts
@@ -67,6 +67,13 @@ function startLeaderCoordinator(channel: MemorySharedChannel) {
return coordinator;
}
+function getCoordinatorCaches(coordinator: SharedPollingCoordinator) {
+ return coordinator as unknown as {
+ latestResults: Map<string, unknown>;
+ lastPublished: Map<string, unknown>;
+ };
+}
+
describe("LeaderElection", () => {
it("elects one visible leader and keeps the second visible tab as follower", () => {
let now = 1_000;
@@ -269,4 +276,118 @@ describe("SharedPollingCoordinator", () => {
coordinator.stop();
});
+
+ it("bounds cached results with LRU eviction and removes idle entries on ticks", () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(1_000);
+ const channel = new MemorySharedChannel();
+ const coordinator = startLeaderCoordinator(channel);
+
+ for (let index = 1; index <= 32; index += 1) {
+ coordinator.publish(`company:resource-${index}`, { index }, index);
+ }
+ channel.emit({ type: "request", key: "company:resource-1", from: "follower", at: 1_000 });
+ coordinator.publish("company:resource-1", { index: 1, refreshed: true }, 33);
+ coordinator.publish("company:resource-33", { index: 33 }, 34);
+
+ const caches = getCoordinatorCaches(coordinator);
+ expect(caches.latestResults.size).toBe(32);
+ expect(caches.lastPublished.size).toBe(32);
+ expect(caches.latestResults.has("company:resource-1")).toBe(true);
+ expect(caches.lastPublished.has("company:resource-1")).toBe(true);
+ expect(caches.latestResults.has("company:resource-2")).toBe(false);
+ expect(caches.lastPublished.has("company:resource-2")).toBe(false);
+
+ vi.advanceTimersByTime(5 * 60_000 + 10_000);
+ expect(caches.latestResults.size).toBe(0);
+ expect(caches.lastPublished.size).toBe(0);
+
+ coordinator.stop();
+ });
+
+ it("retains listenerless broadcasts through quick resource resubscriptions", () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(1_000);
+ const channel = new MemorySharedChannel();
+ const coordinator = startLeaderCoordinator(channel);
+ const message = {
+ type: "result" as const,
+ key: "company:live-runs",
+ from: "follower",
+ at: 1_000,
+ dataUpdatedAt: 100,
+ data: [{ id: "run-1" }],
+ };
+
+ channel.emit(message);
+ expect(getCoordinatorCaches(coordinator).latestResults.size).toBe(1);
+
+ const firstListener = vi.fn();
+ const unsubscribe = coordinator.subscribeResource(message.key, firstListener);
+ expect(firstListener).toHaveBeenCalledWith(message);
+ expect(getCoordinatorCaches(coordinator).latestResults.size).toBe(1);
+
+ unsubscribe();
+ expect(getCoordinatorCaches(coordinator).latestResults.size).toBe(1);
+
+ const remountedListener = vi.fn();
+ const unsubscribeRemounted = coordinator.subscribeResource(message.key, remountedListener);
+ expect(remountedListener).toHaveBeenCalledWith(message);
+
+ unsubscribeRemounted();
+ vi.advanceTimersByTime(5 * 60_000 + 10_000);
+ expect(getCoordinatorCaches(coordinator).latestResults.size).toBe(0);
+
+ coordinator.stop();
+ });
+
+ it("keeps active publish dedupe entries when inactive keys exceed the cache limit", () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(1_000);
+ const channel = new MemorySharedChannel();
+ const coordinator = startLeaderCoordinator(channel);
+ const unsubscribe = coordinator.subscribeResource("company:resource-1", vi.fn());
+
+ for (let index = 1; index <= 33; index += 1) {
+ coordinator.publish(`company:resource-${index}`, { index }, index);
+ }
+ coordinator.publish("company:resource-1", { index: 1 }, 34);
+
+ expect(channel.posts.filter((message) => message.type === "result")).toHaveLength(33);
+ const caches = getCoordinatorCaches(coordinator);
+ expect(caches.latestResults.size).toBe(33);
+ expect(caches.lastPublished.size).toBe(33);
+ expect(caches.lastPublished.has("company:resource-1")).toBe(true);
+
+ vi.advanceTimersByTime(5 * 60_000 + 10_000);
+ expect(caches.latestResults.size).toBe(1);
+ expect(caches.lastPublished.size).toBe(1);
+ coordinator.publish("company:resource-1", { index: 1 }, 35);
+ expect(channel.posts.filter((message) => message.type === "result")).toHaveLength(33);
+
+ unsubscribe();
+ vi.advanceTimersByTime(5 * 60_000 - 1);
+ expect(caches.latestResults.size).toBe(1);
+ expect(caches.lastPublished.size).toBe(1);
+ vi.advanceTimersByTime(10_001);
+ expect(caches.latestResults.size).toBe(0);
+ expect(caches.lastPublished.size).toBe(0);
+
+ coordinator.stop();
+ });
+
+ it("skips fingerprint traversal for older-or-equal publish snapshots", () => {
+ const channel = new MemorySharedChannel();
+ const coordinator = startLeaderCoordinator(channel);
+ const ownKeys = vi.fn(() => []);
+ const staleData = new Proxy({}, { ownKeys });
+
+ coordinator.publish("company:live-runs", [{ id: "run-1" }], 100);
+ coordinator.publish("company:live-runs", staleData, 100);
+
+ expect(ownKeys).not.toHaveBeenCalled();
+ expect(channel.posts.filter((message) => message.type === "result")).toHaveLength(1);
+
+ coordinator.stop();
+ });
});
diff --git a/ui/src/lib/cross-tab-poll.ts b/ui/src/lib/cross-tab-poll.ts
index 116438d46f..46af27f766 100644
--- a/ui/src/lib/cross-tab-poll.ts
+++ b/ui/src/lib/cross-tab-poll.ts
@@ -186,20 +186,86 @@ export class LeaderElection {
function stableFingerprint(value: unknown): string {
const seen = new WeakSet<object>();
+ let hashA = 0xdeadbeef;
+ let hashB = 0x41c6ce57;
+
+ const write = (chunk: string) => {
+ for (let index = 0; index < chunk.length; index += 1) {
+ const code = chunk.charCodeAt(index);
+ hashA = Math.imul(hashA ^ code, 2654435761);
+ hashB = Math.imul(hashB ^ code, 1597334677);
+ }
+ };
+
+ const visit = (entry: unknown, inArray = false): void => {
+ if (entry === null) {
+ write("null");
+ return;
+ }
+ switch (typeof entry) {
+ case "string":
+ write(JSON.stringify(entry));
+ return;
+ case "boolean":
+ write(entry ? "true" : "false");
+ return;
+ case "number":
+ write(Number.isFinite(entry) ? String(entry) : "null");
+ return;
+ case "undefined":
+ write(inArray ? "null" : "undefined");
+ return;
+ case "bigint":
+ write(`bigint:${entry}`);
+ return;
+ case "symbol":
+ write(`symbol:${String(entry)}`);
+ return;
+ case "function":
+ write(`function:${String(entry)}`);
+ return;
+ case "object":
+ break;
+ }
+
+ const object = entry as Record<string, unknown>;
+ if (seen.has(object)) {
+ write("[Circular]");
+ return;
+ }
+ seen.add(object);
+ const toJSON = object.toJSON;
+ if (typeof toJSON === "function") {
+ visit(toJSON.call(object), inArray);
+ return;
+ }
+ if (Array.isArray(object)) {
+ write("[");
+ for (const item of object) {
+ visit(item, true);
+ write(",");
+ }
+ write("]");
+ return;
+ }
+
+ write("{");
+ for (const key of Object.keys(object).sort()) {
+ const item = object[key];
+ if (item === undefined || typeof item === "function" || typeof item === "symbol") continue;
+ write(JSON.stringify(key));
+ write(":");
+ visit(item);
+ write(",");
+ }
+ write("}");
+ };
+
try {
- return JSON.stringify(value, (_key, entry: unknown) => {
- if (!entry || typeof entry !== "object") return entry;
- if (seen.has(entry)) return "[Circular]";
- seen.add(entry);
- if (Array.isArray(entry)) return entry;
- const record = entry as Record<string, unknown>;
- return Object.keys(record)
- .sort()
- .reduce<Record<string, unknown>>((acc, key) => {
- acc[key] = record[key];
- return acc;
- }, {});
- });
+ visit(value);
+ hashA = Math.imul(hashA ^ (hashA >>> 16), 2246822507) ^ Math.imul(hashB ^ (hashB >>> 13), 3266489909);
+ hashB = Math.imul(hashB ^ (hashB >>> 16), 2246822507) ^ Math.imul(hashA ^ (hashA >>> 13), 3266489909);
+ return `${(hashB >>> 0).toString(36)}${(hashA >>> 0).toString(36)}`;
} catch {
return String(value);
}
@@ -394,6 +460,8 @@ export interface SharedPollingCoordinatorOptions {
const DEFAULT_COORDINATOR_TICK_MS = 1_000;
const DEFAULT_PUBLISH_DEBOUNCE_MS = 1_000;
+const MAX_COORDINATOR_CACHE_ENTRIES = 32;
+const COORDINATOR_CACHE_TTL_MS = 5 * 60_000;
const TAB_ID_STORAGE_KEY = "paperclip:shared-poll:tab-id";
function sanitizeCompanyId(companyId: string): string {
@@ -464,11 +532,15 @@ export class SharedPollingCoordinator {
private readonly getVisible: () => boolean;
private readonly listeners = new Set<SharedPollingListener>();
private readonly resourceListeners = new Map<string, Set<SharedPollingResourceListener>>();
- private readonly latestResults = new Map<string, SharedMessage>();
+ private readonly latestResults = new Map<string, {
+ message: SharedMessage;
+ lastAccessedAt: number;
+ }>();
private readonly lastPublished = new Map<string, {
dataUpdatedAt: number;
fingerprint: string;
sentAt: number;
+ lastAccessedAt: number;
}>();
private readonly pendingPublishes = new Map<string, {
data: unknown;
@@ -548,11 +620,14 @@ export class SharedPollingCoordinator {
this.resourceListeners.set(key, listeners);
}
listeners.add(listener);
- const latest = this.latestResults.get(key);
+ const latest = this.getLatestResult(key);
if (latest) listener(latest);
return () => {
listeners?.delete(listener);
- if (listeners?.size === 0) this.resourceListeners.delete(key);
+ if (listeners?.size === 0) {
+ this.resourceListeners.delete(key);
+ this.markInactive(key);
+ }
};
}
@@ -568,16 +643,15 @@ export class SharedPollingCoordinator {
publish(key: string, data: unknown, dataUpdatedAt = this.now()): void {
if (!this.snapshot.isLeader) return;
if (dataUpdatedAt <= 0) return;
+ const last = this.getLastPublished(key);
+ if (last && dataUpdatedAt <= last.dataUpdatedAt) return;
+ const pending = this.pendingPublishes.get(key);
+ if (pending && dataUpdatedAt < pending.dataUpdatedAt) return;
const fingerprint = stableFingerprint(data);
- const last = this.lastPublished.get(key);
- if (last) {
- if (dataUpdatedAt <= last.dataUpdatedAt) return;
- if (fingerprint === last.fingerprint) {
- this.cancelPendingPublish(key);
- return;
- }
+ if (last && fingerprint === last.fingerprint) {
+ this.cancelPendingPublish(key);
+ return;
}
- const pending = this.pendingPublishes.get(key);
if (pending) {
if (dataUpdatedAt < pending.dataUpdatedAt) return;
if (dataUpdatedAt === pending.dataUpdatedAt && fingerprint === pending.fingerprint) return;
@@ -611,8 +685,8 @@ export class SharedPollingCoordinator {
dataUpdatedAt,
data,
};
- this.lastPublished.set(key, { dataUpdatedAt, fingerprint, sentAt });
- this.latestResults.set(key, message);
+ this.setLastPublished(key, { dataUpdatedAt, fingerprint, sentAt, lastAccessedAt: sentAt });
+ this.setLatestResult(key, message);
this.channel.post(message);
}
@@ -636,6 +710,7 @@ export class SharedPollingCoordinator {
}
private tick(): void {
+ this.evictIdleEntries();
if (this.localOnlyFallback) {
this.setSnapshot({ isLeader: this.getVisible() });
return;
@@ -648,17 +723,90 @@ export class SharedPollingCoordinator {
if (message.from === this.tabId) return;
if (message.type === "request") {
if (!this.snapshot.isLeader) return;
- const latest = this.latestResults.get(message.key);
+ const latest = this.getLatestResult(message.key);
if (latest) this.channel.post({ ...latest, from: this.tabId });
return;
}
- this.latestResults.set(message.key, message);
+ this.setLatestResult(message.key, message);
const listeners = this.resourceListeners.get(message.key);
- if (!listeners) return;
+ if (!listeners || listeners.size === 0) return;
for (const listener of listeners) listener(message);
}
+ private getLatestResult(key: string): SharedMessage | undefined {
+ const entry = this.latestResults.get(key);
+ if (!entry) return undefined;
+ entry.lastAccessedAt = this.now();
+ this.latestResults.delete(key);
+ this.latestResults.set(key, entry);
+ return entry.message;
+ }
+
+ private setLatestResult(key: string, message: SharedMessage): void {
+ this.latestResults.delete(key);
+ this.latestResults.set(key, { message, lastAccessedAt: this.now() });
+ this.evictLeastRecentlyUsed(this.latestResults);
+ }
+
+ private getLastPublished(key: string): {
+ dataUpdatedAt: number;
+ fingerprint: string;
+ sentAt: number;
+ lastAccessedAt: number;
+ } | undefined {
+ const entry = this.lastPublished.get(key);
+ if (!entry) return undefined;
+ entry.lastAccessedAt = this.now();
+ this.lastPublished.delete(key);
+ this.lastPublished.set(key, entry);
+ return entry;
+ }
+
+ private setLastPublished(key: string, entry: {
+ dataUpdatedAt: number;
+ fingerprint: string;
+ sentAt: number;
+ lastAccessedAt: number;
+ }): void {
+ this.lastPublished.delete(key);
+ this.lastPublished.set(key, entry);
+ this.evictLeastRecentlyUsed(this.lastPublished);
+ }
+
+ private evictLeastRecentlyUsed<T>(entries: Map<string, T>): void {
+ const inactiveKeys = Array.from(entries.keys()).filter(
+ (key) => (this.resourceListeners.get(key)?.size ?? 0) === 0,
+ );
+ while (inactiveKeys.length > MAX_COORDINATOR_CACHE_ENTRIES) {
+ const oldestInactiveKey = inactiveKeys.shift();
+ if (oldestInactiveKey === undefined) return;
+ entries.delete(oldestInactiveKey);
+ }
+ }
+
+ private evictIdleEntries(): void {
+ const expiresBefore = this.now() - COORDINATOR_CACHE_TTL_MS;
+ for (const [key, entry] of this.latestResults) {
+ if ((this.resourceListeners.get(key)?.size ?? 0) > 0) continue;
+ if (entry.lastAccessedAt < expiresBefore) this.latestResults.delete(key);
+ }
+ for (const [key, entry] of this.lastPublished) {
+ if ((this.resourceListeners.get(key)?.size ?? 0) > 0) continue;
+ if (entry.lastAccessedAt < expiresBefore) this.lastPublished.delete(key);
+ }
+ }
+
+ private markInactive(key: string): void {
+ const inactiveAt = this.now();
+ const latest = this.latestResults.get(key);
+ if (latest) latest.lastAccessedAt = inactiveAt;
+ const published = this.lastPublished.get(key);
+ if (published) published.lastAccessedAt = inactiveAt;
+ this.evictLeastRecentlyUsed(this.latestResults);
+ this.evictLeastRecentlyUsed(this.lastPublished);
+ }
+
private setSnapshot(snapshot: SharedPollingSnapshot): void {
if (snapshot.isLeader === this.snapshot.isLeader) return;
this.snapshot = snapshot;