Keep the default cache limit for a stored legacy zero size

Older builds stored the cache limit under the legacy cacheLimitSize key
and rejected zero at startup, keeping the 1GB default. Accepting zero
from that key would silently turn those prefs files into an unlimited
cache after upgrade. Only the current maxCacheSize key may carry zero
(unlimited); a legacy zero falls through to the default.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016Q2tBCuePZJeeCkDDxu1m3

Author: jlobue10

packages/gui/src/electron/main.tsx

@@ -80,6 +80,7 @@ import {
   addBypassCommand,
 } from './utils/pairStore';
 import * as privatePreferences from './utils/privatePreferences';
+import resolveStoredMaxCacheSize from './utils/resolveStoredMaxCacheSize';
 import toCamelCase from './utils/toCamelCase';
 import { setUserDataDir } from './utils/userData';
 import webSocketBridgeBindEvents from './utils/webSocketBridge';
@@ -118,12 +119,7 @@ const prefs = readPrefs();
 const defaultCacheFolder = path.join(app.getPath('cache'), app.getName());
 const cacheDirectory: string = prefs.cacheFolder || defaultCacheFolder;
 
-// `cacheLimitSize` is the legacy preference key older versions of the
-// settings UI stored the value under. Invalid values are ignored because the
-// CacheManager constructor rejects negative sizes; zero means unlimited.
-const storedMaxCacheSize: number | undefined = [prefs.maxCacheSize, prefs.cacheLimitSize].find(
-  (size) => typeof size === 'number' && Number.isFinite(size) && size >= 0,
-);
+const storedMaxCacheSize: number | undefined = resolveStoredMaxCacheSize(prefs);
 
 const cacheManager = new CacheManager({
   cacheDirectory,

packages/gui/src/electron/utils/resolveStoredMaxCacheSize.test.ts

@@ -0,0 +1,37 @@
+import resolveStoredMaxCacheSize from './resolveStoredMaxCacheSize';
+
+describe('resolveStoredMaxCacheSize', () => {
+  it('accepts a positive size from the current key', () => {
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: 2048 })).toBe(2048);
+  });
+
+  it('accepts zero (unlimited) from the current key', () => {
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: 0 })).toBe(0);
+  });
+
+  it('accepts a positive size from the legacy key', () => {
+    expect(resolveStoredMaxCacheSize({ cacheLimitSize: 1024 })).toBe(1024);
+  });
+
+  it('ignores a legacy zero so the default limit still applies after upgrade', () => {
+    // older builds rejected a stored zero at startup and kept the default
+    // limit, so a migrated zero must not silently become unlimited
+    expect(resolveStoredMaxCacheSize({ cacheLimitSize: 0 })).toBeUndefined();
+  });
+
+  it('prefers the current key over the legacy key', () => {
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: 512, cacheLimitSize: 1024 })).toBe(512);
+  });
+
+  it('falls back to a valid legacy size when the current key is invalid', () => {
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: -1, cacheLimitSize: 1024 })).toBe(1024);
+  });
+
+  it('ignores invalid values', () => {
+    expect(resolveStoredMaxCacheSize({})).toBeUndefined();
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: -5 })).toBeUndefined();
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: Number.NaN })).toBeUndefined();
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: Number.POSITIVE_INFINITY })).toBeUndefined();
+    expect(resolveStoredMaxCacheSize({ maxCacheSize: '1024', cacheLimitSize: '2048' })).toBeUndefined();
+  });
+});

packages/gui/src/electron/utils/resolveStoredMaxCacheSize.ts

@@ -0,0 +1,24 @@
+type StoredCacheSizePrefs = {
+  maxCacheSize?: unknown;
+  cacheLimitSize?: unknown;
+};
+
+const isStoredCacheSize = (size: unknown): size is number => typeof size === 'number' && Number.isFinite(size);
+
+// `cacheLimitSize` is the legacy preference key older versions of the
+// settings UI stored the value under. Invalid values are ignored because the
+// CacheManager constructor rejects negative sizes. Zero means unlimited, but
+// only under the current key: builds that wrote `cacheLimitSize` rejected
+// zero at startup and kept the default limit, so a stored legacy zero must
+// keep falling through to the default instead of disabling eviction.
+export default function resolveStoredMaxCacheSize(prefs: StoredCacheSizePrefs): number | undefined {
+  if (isStoredCacheSize(prefs.maxCacheSize) && prefs.maxCacheSize >= 0) {
+    return prefs.maxCacheSize;
+  }
+
+  if (isStoredCacheSize(prefs.cacheLimitSize) && prefs.cacheLimitSize > 0) {
+    return prefs.cacheLimitSize;
+  }
+
+  return undefined;
+}