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

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]);
 };

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

@@ -0,0 +1,51 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { useConsoleFeaturesConfig } from './useConsoleFeaturesConfig';
+
+describe('useConsoleFeaturesConfig', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns airplaneMode false while loading (initial state)', () => {
+    global.fetch = jest.fn().mockReturnValue(new Promise(() => {}));
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+
+  it('returns airplaneMode true when /api/features responds { airplaneMode: true }', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ airplaneMode: true }),
+    });
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(result.current.airplaneMode).toBe(true));
+  });
+
+  it('returns airplaneMode false when /api/features responds { airplaneMode: false }', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ airplaneMode: false }),
+    });
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(global.fetch).toHaveBeenCalled());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+
+  it('returns airplaneMode false on fetch failure', async () => {
+    global.fetch = jest.fn().mockRejectedValue(new Error('network error'));
+    const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(consoleSpy).toHaveBeenCalled());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+
+  it('returns airplaneMode false when response is not ok', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: false,
+      json: async () => ({ airplaneMode: true }),
+    });
+    const { result } = renderHook(() => useConsoleFeaturesConfig());
+    await waitFor(() => expect(global.fetch).toHaveBeenCalled());
+    expect(result.current.airplaneMode).toBe(false);
+  });
+});

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

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+
+export type ConsoleFeaturesConfig = {
+  airplaneMode: boolean;
+};
+
+const FEATURES_PATH = '/api/features';
+
+export const useConsoleFeaturesConfig = (): ConsoleFeaturesConfig => {
+  const [config, setConfig] = useState<ConsoleFeaturesConfig>({
+    airplaneMode: false,
+  });
+
+  useEffect(() => {
+    fetch(FEATURES_PATH)
+      .then(async (response) => {
+        if (!response.ok) {
+          return;
+        }
+        const data: unknown = await response.json();
+        if (
+          data !== null &&
+          typeof data === 'object' &&
+          !Array.isArray(data) &&
+          'airplaneMode' in data &&
+          typeof (data as { airplaneMode: unknown }).airplaneMode === 'boolean'
+        ) {
+          setConfig({
+            airplaneMode: (data as { airplaneMode: boolean }).airplaneMode,
+          });
+        }
+      })
+      .catch((err: unknown) => {
+        console.warn('Failed to fetch /api/features', err);
+      });
+  }, []);
+
+  return config;
+};

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

@@ -1,4 +1,5 @@
 import { act, renderHook, waitFor } from '@testing-library/react';
+import type { AirplaneSnapshot } from '../lib/airplaneSnapshot';
 import { CONSOLE_TABS } from '../logic/types';
 import {
   CONSOLE_TAB_REFRESH_INTERVAL_MS,
@@ -257,4 +258,218 @@ describe('useConsoleTabData', () => {
     expect(result.current.error).toBe('No project specified in the URL path.');
     expect(fetchMock).not.toHaveBeenCalled();
   });
+
+  it('renders board items from airplane snapshot without fetching when network rejects', async () => {
+    const fetchMock = jest.fn().mockRejectedValue(new Error('network down'));
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const airplaneSnapshot: AirplaneSnapshot = {
+      capturedAt: '2026-08-01T10:00:00Z',
+      failures: [],
+      items: {},
+      tabs: {
+        acme: {
+          prs: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+            items: [
+              {
+                number: 1,
+                title: 'Offline PR',
+                url: 'https://github.com/o/r/pull/1',
+                repo: 'o/r',
+                nameWithOwner: 'o/r',
+                projectItemId: 'PVTI_1',
+                itemId: 'PVTI_1',
+                isPr: true,
+                story: 'regular',
+                status: 'Awaiting Quality Check',
+                nextActionDate: null,
+                nextActionHour: null,
+                dependedIssueUrls: [],
+                labels: [],
+                createdAt: '2026-08-01T00:00:00Z',
+                relatedOpenPullRequestUrls: [],
+                agent: null,
+              },
+            ],
+          },
+          'workflow-blocker': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'failed-preparation': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-human': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-agent': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          stories: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+        },
+      },
+    };
+
+    const { result } = renderHook(() =>
+      useConsoleTabData('acme', airplaneSnapshot),
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(result.current.error).toBeNull();
+    expect(result.current.snapshots.prs?.items).toHaveLength(1);
+    expect(result.current.snapshots.prs?.items[0].title).toBe('Offline PR');
+    expect(result.current.snapshots.prs?.generatedAt).toBe(
+      '2026-08-01T10:00:00Z',
+    );
+  });
+
+  it('stops the 60-second periodic refresh while an airplane snapshot is in use', async () => {
+    jest.useFakeTimers();
+    const fetchMock = jest.fn().mockRejectedValue(new Error('network down'));
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const airplaneSnapshot: AirplaneSnapshot = {
+      capturedAt: '2026-08-01T10:00:00Z',
+      failures: [],
+      items: {},
+      tabs: {
+        acme: {
+          prs: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'workflow-blocker': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'failed-preparation': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-human': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          'todo-by-agent': {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+          stories: {
+            generatedAt: '2026-08-01T10:00:00Z',
+            statusOptions: [],
+            storyOptions: [],
+            storyColors: {},
+            items: [],
+            stories: [],
+            defaultNameWithOwner: null,
+            fromCache: false,
+            storyOrder: [],
+          },
+        },
+      },
+    };
+
+    const { result } = renderHook(() =>
+      useConsoleTabData('acme', airplaneSnapshot),
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    act(() => {
+      jest.advanceTimersByTime(CONSOLE_TAB_REFRESH_INTERVAL_MS * 3);
+    });
+
+    expect(fetchMock).not.toHaveBeenCalled();
+    jest.useRealTimers();
+  });
 });