@openchambery/web 2.1.9-beta.5 → 2.1.9-beta.7

package/server/lib/session-index/sync-runtime.js

@@ -7,6 +7,13 @@ const FULL_RECONCILE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const FETCH_TIMEOUT_MS = 6_000;
 const INTERACTIVE_YIELD_MS = 1_000;
 const LONG_POLL_MAX_MS = 25_000;
+/**
+ * Fixed trailing window for background progress tips. Each SSE tip makes every
+ * connected client GET the full snapshot, and one sync batch bumps the revision
+ * once per directory and once per child-flag check (~300+ per cold start). Keep
+ * progress `notify()` calls on the throttled path; only new batch, idle, stop and
+ * `publishChange()` may broadcast immediately. sync-runtime.test.js bounds this.
+ */
 const REVISION_TIP_THROTTLE_MS = 500;
 
 const normalizeDirectory = (value) => {
@@ -75,6 +82,7 @@ export const createSessionIndexSyncRuntime = ({
   projectSessions = null,
   fetchFn = globalThis.fetch,
   resolveDirectory = (value) => value,
+  isDirectoryMissing = null,
   now = Date.now,
   setTimer = setTimeout,
   clearTimer = clearTimeout,
@@ -136,6 +144,9 @@ export const createSessionIndexSyncRuntime = ({
     }
   };
 
+  // `immediate` is reserved for edges a client must see without delay (new batch,
+  // idle, stop, external change). Progress callers must pass nothing: an immediate
+  // progress tip reintroduces one full client snapshot GET per directory/child.
   const notify = (immediate = false, cause) => {
     if (stopped && !immediate) return;
     revision += 1;
@@ -172,6 +183,12 @@ export const createSessionIndexSyncRuntime = ({
     .find((entry) => entry.directory === directory);
 
   const fetchDirectory = async (task) => {
+    if (isDirectoryMissing && await isDirectoryMissing(task.directory)) {
+      if (stopped || task.runtimeKey !== sessionIndexService.getRuntimeKey()) return 'discarded';
+      sessionIndexService.removeEmptyDirectory(task.directory);
+      return;
+    }
+    if (stopped || task.runtimeKey !== sessionIndexService.getRuntimeKey()) return 'discarded';
     // v2 `session.list` cursor pagination. Collect candidates across pages,
     // then re-project once before commit so a Host archive that lands mid-sync
     // cannot resurrect a row. Root/system filters run before the 20-slot budget.
@@ -315,6 +332,8 @@ export const createSessionIndexSyncRuntime = ({
   };
 
   const fetchChildFlag = async (task) => {
+    if (isDirectoryMissing && await isDirectoryMissing(task.directory)) return 'discarded';
+    if (stopped || task.runtimeKey !== sessionIndexService.getRuntimeKey()) return 'discarded';
     const controller = new AbortController();
     currentController = controller;
     currentWasPreempted = false;
@@ -503,6 +522,7 @@ export const createSessionIndexSyncRuntime = ({
   const stop = () => {
     if (stopped) return;
     stopped = true;
+    if (cleanupTimer !== undefined) clearTimer(cleanupTimer);
     currentController?.abort();
     const interruptedDirectories = [...queuedDirectories];
     queue.length = 0;
@@ -513,5 +533,29 @@ export const createSessionIndexSyncRuntime = ({
     notify(true);
   };
 
+  let cleanupTimer;
+  const cleanupMissingDirectories = async () => {
+    const key = sessionIndexService.getRuntimeKey();
+    let changed = false;
+    try {
+      for (const entry of sessionIndexService.snapshot().directories) {
+        if (stopped || key !== sessionIndexService.getRuntimeKey()) break;
+        if (entry.sessions.length || entry.hasMore) continue;
+        const missing = await isDirectoryMissing(entry.directory);
+        if (stopped || key !== sessionIndexService.getRuntimeKey()) break;
+        if (missing) changed = sessionIndexService.removeEmptyDirectory(entry.directory) || changed;
+      }
+      if (changed && !stopped && key === sessionIndexService.getRuntimeKey()) notify(true);
+    } catch (error) {
+      console.warn('[SessionIndex] Directory cleanup failed:', error);
+    } finally {
+      if (!stopped) {
+        cleanupTimer = setTimer(cleanupMissingDirectories, 60_000);
+        cleanupTimer?.unref?.();
+      }
+    }
+  };
+  if (isDirectoryMissing) void cleanupMissingDirectories();
+
   return { enqueue, noteInteractiveRequest, publishChange, snapshot, waitForChange, stop };
 };

package/server/lib/session-index/sync-runtime.test.js

@@ -41,6 +41,33 @@ const isFullyIdle = (runtime) => (
 );
 
 describe('session index background sync runtime', () => {
+  it('rechecks missing directories periodically and stops maintenance on shutdown', async () => {
+    const service = createService([{ directory: '/repo', sessions: [], hasMore: false }]);
+    service.removeEmptyDirectory = vi.fn(() => true);
+    const isDirectoryMissing = vi.fn(async () => false);
+    const timers = [];
+    const clearTimer = vi.fn();
+    const runtime = createSessionIndexSyncRuntime({
+      sessionIndexService: service,
+      isDirectoryMissing,
+      setTimer: (fn, ms) => { const timer = { fn, ms }; timers.push(timer); return timer; },
+      clearTimer,
+    });
+    await waitUntil(() => timers.length === 1);
+    expect(timers[0].ms).toBe(60_000);
+    expect(service.removeEmptyDirectory).not.toHaveBeenCalled();
+    isDirectoryMissing.mockResolvedValue(true);
+    await timers[0].fn();
+    expect(service.removeEmptyDirectory).toHaveBeenCalledWith('/repo');
+    expect(runtime.snapshot().revision).toBe(1);
+    runtime.stop();
+    expect(clearTimer).toHaveBeenCalledWith(timers[1]);
+    const calls = isDirectoryMissing.mock.calls.length;
+    await timers[1].fn();
+    expect(isDirectoryMissing).toHaveBeenCalledTimes(calls);
+    expect(timers).toHaveLength(2);
+  });
+
   it('coalesces hundreds of directory/child checks and immediately publishes the final revision', async () => {
     vi.useFakeTimers();
     try {
@@ -80,6 +107,12 @@ describe('session index background sync runtime', () => {
       expect(service.replaceDirectory).toHaveBeenCalledTimes(15);
       expect(service.replaceChildSessions).toHaveBeenCalledTimes(300);
       expect(isFullyIdle(runtime)).toBe(true);
+      // Relay cold-start budget: 315 internal revisions must reach SSE as a handful
+      // of tips (one per 500ms window + immediate edges), never one per directory or
+      // child check. Each tip costs every Relay client a full snapshot GET; the
+      // uncoalesced Host measured ~316 tips per mobile cold start.
+      expect(runtime.snapshot().revision).toBeGreaterThan(300);
+      expect(tips.mock.calls.length).toBeLessThanOrEqual(Math.ceil(2650 / 500) + 3);
       expect(tips).toHaveBeenCalledTimes(8);
       expect(tips.mock.calls.map(([tip]) => tip.revision)).toEqual(revisionsAtDelivery);
       for (const [tip] of tips.mock.calls) expect(tip).not.toHaveProperty('cause');