github-issue-tower-defence-management 2.7.0 → 2.9.0

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useAirplaneMode.test.ts

@@ -0,0 +1,304 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import {
+  type AirplaneSnapshot,
+  readAirplaneModeFlag,
+  writeAirplaneModeFlag,
+} from '../lib/airplaneSnapshot';
+import { useAirplaneMode } from './useAirplaneMode';
+
+const makeMinimalSnapshot = (
+  overrides: Partial<AirplaneSnapshot> = {},
+): AirplaneSnapshot => ({
+  capturedAt: '2026-01-01T00:00:00Z',
+  tabs: {},
+  items: {},
+  failures: [],
+  ...overrides,
+});
+
+const encodeSseEvent = (data: unknown): string =>
+  `data: ${JSON.stringify(data)}\n\n`;
+
+const buildSseBody = (events: unknown[]): ReadableStream<Uint8Array> => {
+  const encoder = new TextEncoder();
+  const chunks = events.map((e) => encoder.encode(encodeSseEvent(e)));
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(chunk);
+      }
+      controller.close();
+    },
+  });
+};
+
+const mockFetchSse = (events: unknown[]): void => {
+  global.fetch = jest.fn().mockResolvedValue({
+    ok: true,
+    status: 200,
+    body: buildSseBody(events),
+  });
+};
+
+const mockCacheApi = (): {
+  stored: AirplaneSnapshot | null;
+  cacheStore: Map<string, string>;
+} => {
+  let stored: AirplaneSnapshot | null = null;
+  const cacheStore = new Map<string, string>();
+
+  const mockCache = {
+    put: jest.fn(async (_key: string, response: Response) => {
+      const text = await response.text();
+      cacheStore.set('snapshot', text);
+      stored = JSON.parse(text) as AirplaneSnapshot;
+    }),
+    match: jest.fn(async () => {
+      if (!cacheStore.has('snapshot')) {
+        return undefined;
+      }
+      return new Response(cacheStore.get('snapshot'), {
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }),
+    delete: jest.fn(),
+  };
+
+  Object.defineProperty(global, 'caches', {
+    writable: true,
+    value: {
+      open: jest.fn().mockResolvedValue(mockCache),
+      delete: jest.fn().mockResolvedValue(true),
+    },
+  });
+
+  return { stored: stored, cacheStore };
+};
+
+describe('useAirplaneMode', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    mockCacheApi();
+  });
+
+  it('starts in off status', () => {
+    const { result } = renderHook(() => useAirplaneMode());
+    expect(result.current.status).toBe('off');
+    expect(result.current.snapshot).toBeNull();
+    expect(result.current.progress).toBeNull();
+    expect(result.current.failures).toEqual([]);
+  });
+
+  it('does not report on while a fetch is outstanding', async () => {
+    let resolveStream!: () => void;
+    const streamBlocked = new Promise<void>((res) => {
+      resolveStream = res;
+    });
+
+    const encoder = new TextEncoder();
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      body: new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(
+            encoder.encode(
+              encodeSseEvent({ type: 'progress', fetched: 0, total: 5 }),
+            ),
+          );
+          streamBlocked
+            .then(() => {
+              controller.close();
+            })
+            .catch(() => {});
+        },
+      }),
+    });
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    act(() => {
+      result.current.startSync();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('syncing');
+    });
+
+    expect(result.current.status).not.toBe('on');
+
+    resolveStream();
+  });
+
+  it('transitions to on only after the done event with no failures', async () => {
+    const snapshot = makeMinimalSnapshot();
+    mockFetchSse([
+      { type: 'progress', fetched: 0, total: 1 },
+      { type: 'progress', fetched: 1, total: 1 },
+      { type: 'done', snapshot },
+    ]);
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    act(() => {
+      result.current.startSync();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('on');
+    });
+
+    expect(result.current.snapshot).not.toBeNull();
+    expect(result.current.snapshot?.capturedAt).toBe('2026-01-01T00:00:00Z');
+    expect(result.current.failures).toEqual([]);
+  });
+
+  it('sets status to error and does not turn on when the done event has failures', async () => {
+    const snapshot = makeMinimalSnapshot({
+      failures: ['https://github.com/o/r/issues/99'],
+    });
+    mockFetchSse([
+      { type: 'progress', fetched: 0, total: 1 },
+      { type: 'done', snapshot },
+    ]);
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    act(() => {
+      result.current.startSync();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('error');
+    });
+
+    expect(result.current.status).toBe('error');
+    expect(result.current.failures).toContain(
+      'https://github.com/o/r/issues/99',
+    );
+    expect(result.current.snapshot).toBeNull();
+  });
+
+  it('sets status to error when fetch fails', async () => {
+    global.fetch = jest.fn().mockRejectedValue(new Error('network down'));
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    act(() => {
+      result.current.startSync();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('error');
+    });
+
+    expect(result.current.failures).toContain('network down');
+  });
+
+  it('turnOff resets to off and clears snapshot', async () => {
+    const snapshot = makeMinimalSnapshot();
+    mockFetchSse([
+      { type: 'progress', fetched: 0, total: 0 },
+      { type: 'done', snapshot },
+    ]);
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    act(() => {
+      result.current.startSync();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('on');
+    });
+
+    act(() => {
+      result.current.turnOff();
+    });
+
+    expect(result.current.status).toBe('off');
+    expect(result.current.snapshot).toBeNull();
+    expect(result.current.failures).toEqual([]);
+  });
+
+  it('loads stored snapshot from Cache API when flag is on at mount', async () => {
+    const snapshot = makeMinimalSnapshot({
+      capturedAt: '2025-06-01T00:00:00Z',
+    });
+    writeAirplaneModeFlag(true);
+
+    const cacheStore = new Map<string, string>();
+    cacheStore.set('snapshot', JSON.stringify(snapshot));
+
+    const mockCache = {
+      put: jest.fn(),
+      match: jest.fn().mockResolvedValue(
+        new Response(cacheStore.get('snapshot'), {
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      ),
+    };
+    Object.defineProperty(global, 'caches', {
+      writable: true,
+      value: {
+        open: jest.fn().mockResolvedValue(mockCache),
+        delete: jest.fn().mockResolvedValue(true),
+      },
+    });
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('on');
+    });
+
+    expect(result.current.snapshot?.capturedAt).toBe('2025-06-01T00:00:00Z');
+  });
+
+  it('advances progress events during sync', async () => {
+    mockFetchSse([
+      { type: 'progress', fetched: 0, total: 2 },
+      { type: 'progress', fetched: 1, total: 2 },
+      { type: 'progress', fetched: 2, total: 2 },
+      { type: 'done', snapshot: makeMinimalSnapshot() },
+    ]);
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    act(() => {
+      result.current.startSync();
+    });
+
+    await waitFor(() => {
+      expect(result.current.progress?.total).toBe(2);
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('on');
+    });
+  });
+
+  it('sets status to error and does not write the flag when storeAirplaneSnapshot rejects', async () => {
+    Object.defineProperty(global, 'caches', {
+      writable: true,
+      value: {
+        open: jest.fn().mockRejectedValue(new Error('Cache API unavailable')),
+        delete: jest.fn().mockResolvedValue(true),
+      },
+    });
+    mockFetchSse([{ type: 'done', snapshot: makeMinimalSnapshot() }]);
+
+    const { result } = renderHook(() => useAirplaneMode());
+
+    act(() => {
+      result.current.startSync();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe('error');
+    });
+
+    expect(readAirplaneModeFlag()).toBe(false);
+    expect(result.current.snapshot).toBeNull();
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useAirplaneMode.ts

@@ -0,0 +1,167 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  type AirplaneSnapshot,
+  clearAirplaneSnapshot,
+  loadAirplaneSnapshot,
+  parseAirplaneSnapshot,
+  readAirplaneModeFlag,
+  storeAirplaneSnapshot,
+  writeAirplaneModeFlag,
+} from '../lib/airplaneSnapshot';
+
+export type AirplaneModeStatus = 'off' | 'syncing' | 'on' | 'error';
+
+export type AirplaneSyncProgress = {
+  fetched: number;
+  total: number;
+};
+
+export type AirplaneModeState = {
+  status: AirplaneModeStatus;
+  progress: AirplaneSyncProgress | null;
+  snapshot: AirplaneSnapshot | null;
+  failures: string[];
+  startSync: () => void;
+  turnOff: () => void;
+};
+
+const AIRPLANE_SYNC_PATH = '/api/airplanesync';
+
+const parseSyncEvent = (
+  raw: string,
+): { type: string; [key: string]: unknown } | null => {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (
+      parsed !== null &&
+      typeof parsed === 'object' &&
+      !Array.isArray(parsed) &&
+      'type' in parsed &&
+      typeof (parsed as { type: unknown }).type === 'string'
+    ) {
+      return parsed as { type: string; [key: string]: unknown };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+export const useAirplaneMode = (): AirplaneModeState => {
+  const [status, setStatus] = useState<AirplaneModeStatus>('off');
+  const [progress, setProgress] = useState<AirplaneSyncProgress | null>(null);
+  const [snapshot, setSnapshot] = useState<AirplaneSnapshot | null>(null);
+  const [failures, setFailures] = useState<string[]>([]);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  useEffect(() => {
+    if (!readAirplaneModeFlag()) {
+      return;
+    }
+    let cancelled = false;
+    loadAirplaneSnapshot()
+      .then((stored) => {
+        if (cancelled || stored === null) {
+          return;
+        }
+        setSnapshot(stored);
+        setStatus('on');
+      })
+      .catch(() => {
+        writeAirplaneModeFlag(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  const startSync = useCallback((): void => {
+    if (abortControllerRef.current !== null) {
+      abortControllerRef.current.abort();
+    }
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+
+    setStatus('syncing');
+    setProgress({ fetched: 0, total: 0 });
+    setFailures([]);
+
+    fetch(AIRPLANE_SYNC_PATH, { signal: controller.signal })
+      .then(async (response) => {
+        if (!response.ok || response.body === null) {
+          setStatus('error');
+          setFailures([`HTTP ${response.status}`]);
+          return;
+        }
+
+        const reader = response.body
+          .pipeThrough(new TextDecoderStream())
+          .getReader();
+
+        let buffer = '';
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          buffer += value;
+          const blocks = buffer.split('\n\n');
+          buffer = blocks.pop() ?? '';
+          for (const block of blocks) {
+            if (!block.startsWith('data: ')) {
+              continue;
+            }
+            const event = parseSyncEvent(block.slice('data: '.length));
+            if (event === null) {
+              continue;
+            }
+            if (event.type === 'progress') {
+              setProgress({
+                fetched: typeof event.fetched === 'number' ? event.fetched : 0,
+                total: typeof event.total === 'number' ? event.total : 0,
+              });
+            } else if (event.type === 'done') {
+              const parsed = parseAirplaneSnapshot(event.snapshot);
+              if (parsed === null) {
+                setStatus('error');
+                setFailures(['Failed to parse snapshot']);
+                return;
+              }
+              if (parsed.failures.length > 0) {
+                setFailures(parsed.failures);
+                setStatus('error');
+                return;
+              }
+              await storeAirplaneSnapshot(parsed);
+              writeAirplaneModeFlag(true);
+              setSnapshot(parsed);
+              setStatus('on');
+              setFailures([]);
+            }
+          }
+        }
+      })
+      .catch((error: unknown) => {
+        if (error instanceof Error && error.name === 'AbortError') {
+          return;
+        }
+        setStatus('error');
+        setFailures([error instanceof Error ? error.message : String(error)]);
+      });
+  }, []);
+
+  const turnOff = useCallback((): void => {
+    if (abortControllerRef.current !== null) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    setStatus('off');
+    setSnapshot(null);
+    setProgress(null);
+    setFailures([]);
+    writeAirplaneModeFlag(false);
+    clearAirplaneSnapshot().catch(() => {});
+  }, []);
+
+  return { status, progress, snapshot, failures, startSync, turnOff };
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleActionQueue.test.ts

@@ -197,4 +197,19 @@ describe('useConsoleActionQueue', () => {
     });
     expect(result.current.error).toBeNull();
   });
+
+  it('showError sets the error state without touching pending', () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    act(() => {
+      result.current.showError(
+        'Airplane mode',
+        'This action requires a network connection.',
+      );
+    });
+    expect(result.current.error).toEqual({
+      message: 'Airplane mode',
+      reason: 'This action requires a network connection.',
+    });
+    expect(result.current.pending).toBeNull();
+  });
 });

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleActionQueue.ts

@@ -42,6 +42,7 @@ export type ConsoleActionQueue = {
   pending: ConsolePendingActionView | null;
   error: ConsoleActionError | null;
   enqueue: (action: ConsoleQueuedAction) => void;
+  showError: (message: string, reason: string) => void;
   undo: () => void;
   dismissError: () => void;
 };
@@ -89,6 +90,10 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
     setError(null);
   }, []);
 
+  const showError = useCallback((message: string, reason: string): void => {
+    setError({ message, reason });
+  }, []);
+
   const enqueue = useCallback(
     (action: ConsoleQueuedAction): void => {
       if (actionRef.current !== null && !committedRef.current) {
@@ -126,5 +131,5 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
 
   useEffect(() => clearTimer, [clearTimer]);
 
-  return { pending, error, enqueue, undo, dismissError };
+  return { pending, error, enqueue, showError, undo, dismissError };
 };

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleCaches.test.ts

@@ -1,4 +1,5 @@
 import { renderHook } from '@testing-library/react';
+import type { AirplaneSnapshot } from '../lib/airplaneSnapshot';
 import { useConsoleCaches } from './useConsoleCaches';
 
 describe('useConsoleCaches', () => {
@@ -19,4 +20,80 @@ describe('useConsoleCaches', () => {
     rerender();
     expect(result.current).toBe(first);
   });
+
+  it('pre-seeds item detail caches from airplane snapshot so item detail renders with network rejecting', () => {
+    const prUrl = 'https://github.com/owner/repo/pull/42';
+    const airplaneSnapshot: AirplaneSnapshot = {
+      capturedAt: '2026-08-01T10:00:00Z',
+      failures: [],
+      tabs: {},
+      items: {
+        [prUrl]: {
+          body: 'PR body text',
+          comments: [
+            {
+              author: 'alice',
+              body: 'LGTM',
+              createdAt: '2026-08-01T09:00:00Z',
+            },
+          ],
+          state: {
+            state: 'open',
+            merged: false,
+            isPullRequest: true,
+            title: 'Offline PR',
+          },
+          files: [
+            {
+              path: 'src/foo.ts',
+              additions: 3,
+              deletions: 1,
+              status: 'modified',
+              patch: '@@ -1 +1 @@\n-old\n+new',
+              rawUrl: null,
+            },
+          ],
+          commits: [
+            {
+              sha: 'abc123',
+              message: 'fix: something',
+              author: 'alice',
+              authoredAt: '2026-08-01T08:00:00Z',
+            },
+          ],
+          prStatus: {
+            found: true,
+            isConflicted: false,
+            mergeableStatus: 'MERGEABLE',
+            isPassedAllCiJob: true,
+            isCiStateSuccess: true,
+            isBranchOutOfDate: false,
+            missingRequiredCheckNames: [],
+          },
+          relatedPrs: null,
+        },
+      },
+    };
+
+    const { result } = renderHook(() => useConsoleCaches(airplaneSnapshot));
+
+    const cacheKey = 'owner/repo#42';
+    expect(result.current.body.peek(cacheKey)).toBe('PR body text');
+
+    const comments = result.current.comments.peek(cacheKey);
+    expect(comments).toHaveLength(1);
+    expect(comments?.[0].author).toBe('alice');
+
+    const files = result.current.files.peek(cacheKey);
+    expect(files).toHaveLength(1);
+    expect(files?.[0].path).toBe('src/foo.ts');
+
+    const commits = result.current.commits.peek(cacheKey);
+    expect(commits).toHaveLength(1);
+    expect(commits?.[0].sha).toBe('abc123');
+
+    const prStatus = result.current.prStatus.peek(cacheKey);
+    expect(prStatus?.isPassedAllCiJob).toBe(true);
+    expect(prStatus?.mergeableStatus).toBe('MERGEABLE');
+  });
 });

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleCaches.ts

@@ -1,4 +1,5 @@
 import { useMemo } from 'react';
+import type { AirplaneSnapshot } from '../lib/airplaneSnapshot';
 import {
   type ConsoleApiClient,
   createConsoleApiClient,
@@ -24,10 +25,50 @@ export type ConsoleCaches = {
   client: ConsoleApiClient;
 };
 
-export const useConsoleCaches = (): ConsoleCaches => {
+const deriveCacheKey = (url: string): string => {
+  try {
+    const urlObj = new URL(url);
+    const parts = urlObj.pathname.split('/').filter(Boolean);
+    if (parts.length >= 4) {
+      const owner = parts[0];
+      const repoName = parts[1];
+      const number = parts[3];
+      return `${owner}/${repoName}#${number}`;
+    }
+  } catch {}
+  return url;
+};
+
+const populateCachesFromSnapshot = (
+  caches: ConsoleCaches,
+  snapshot: AirplaneSnapshot,
+): void => {
+  for (const [url, item] of Object.entries(snapshot.items)) {
+    const key = deriveCacheKey(url);
+    caches.body.seed(key, item.body);
+    caches.comments.seed(key, item.comments);
+    caches.state.seed(key, item.state);
+    if (item.files !== null) {
+      caches.files.seed(key, item.files);
+    }
+    if (item.commits !== null) {
+      caches.commits.seed(key, item.commits);
+    }
+    if (item.prStatus !== null) {
+      caches.prStatus.seed(key, item.prStatus);
+    }
+    if (item.relatedPrs !== null) {
+      caches.relatedPrs.seed(key, item.relatedPrs);
+    }
+  }
+};
+
+export const useConsoleCaches = (
+  airplaneSnapshot: AirplaneSnapshot | null = null,
+): ConsoleCaches => {
   return useMemo(() => {
     const client = createConsoleApiClient();
-    return {
+    const caches: ConsoleCaches = {
       client,
       body: new ResourceCache<string>(client.fetchItemBody),
       comments: new ResourceCache<ConsoleComment[]>(client.fetchComments),
@@ -41,5 +82,9 @@ export const useConsoleCaches = (): ConsoleCaches => {
         client.fetchPullRequestStatus,
       ),
     };
-  }, []);
+    if (airplaneSnapshot !== null) {
+      populateCachesFromSnapshot(caches, airplaneSnapshot);
+    }
+    return caches;
+  }, [airplaneSnapshot]);
 };