github-issue-tower-defence-management 2.12.1 → 2.13.0

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

@@ -1,6 +1,23 @@
 import { act, renderHook } from '@testing-library/react';
 import { useConsoleActionQueue } from './useConsoleActionQueue';
 
+const OFFLINE_QUEUE_STORAGE_KEY = 'console-offline-action-queue';
+
+const offlinePayload = {
+  itemUrl: 'https://github.com/o/r/pull/851',
+  projectItemId: 'PVTI_1',
+  itemNumber: 851,
+  repo: 'o/r',
+  isPr: true,
+  apiPath: '/api/review',
+  requestBody: {
+    pjcode: 'acme',
+    action: 'approve',
+    prUrl: 'https://github.com/o/r/pull/851',
+    projectItemId: 'PVTI_1',
+  },
+};
+
 const makeAction = (
   overrides: Partial<
     Parameters<ReturnType<typeof useConsoleActionQueue>['enqueue']>[0]
@@ -19,10 +36,12 @@ const flushMicrotasks = (): Promise<void> =>
 describe('useConsoleActionQueue', () => {
   beforeEach(() => {
     jest.useFakeTimers();
+    localStorage.clear();
   });
 
   afterEach(() => {
     jest.useRealTimers();
+    localStorage.clear();
   });
 
   it('advances immediately but only commits after the five second window', () => {
@@ -212,4 +231,268 @@ describe('useConsoleActionQueue', () => {
     });
     expect(result.current.pending).toBeNull();
   });
+  it('adds the action to the offline queue when the commit rejects with a network error', async () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new TypeError('Failed to fetch')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    expect(result.current.error).toBeNull();
+    expect(result.current.offlineActions).toHaveLength(1);
+    expect(result.current.offlineActions[0].message).toBe('Approved — PR #851');
+    expect(result.current.offlineActions[0].apiPath).toBe('/api/review');
+  });
+
+  it('surfaces a server error as an error rather than queuing it offline', async () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new Error('HTTP 422 review cannot be requested')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    expect(result.current.error).toEqual({
+      message: 'Approved — PR #851',
+      reason: 'HTTP 422 review cannot be requested',
+    });
+    expect(result.current.offlineActions).toHaveLength(0);
+  });
+
+  it('keeps the offline queue in localStorage so it survives a remount', async () => {
+    const { result, unmount } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new TypeError('Failed to fetch')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    expect(result.current.offlineActions).toHaveLength(1);
+    unmount();
+
+    const { result: result2 } = renderHook(() => useConsoleActionQueue());
+    expect(result2.current.offlineActions).toHaveLength(1);
+    expect(result2.current.offlineActions[0].message).toBe(
+      'Approved — PR #851',
+    );
+  });
+
+  it('does not send anything before confirmOfflineAction is called', async () => {
+    const fetchMock = jest.fn();
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new TypeError('Failed to fetch')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    expect(result.current.offlineActions).toHaveLength(1);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('sends the stored request and removes the action when confirmOfflineAction is called', async () => {
+    const fetchMock = jest.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({}),
+    }));
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new TypeError('Failed to fetch')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    const id = result.current.offlineActions[0].id;
+    await act(async () => {
+      await result.current.confirmOfflineAction(id);
+    });
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/review',
+      expect.objectContaining({ method: 'POST' }),
+    );
+    expect(result.current.offlineActions).toHaveLength(0);
+    expect(result.current.error).toBeNull();
+  });
+
+  it('sets an error and keeps the action when confirmOfflineAction encounters a network error', async () => {
+    const fetchMock = jest
+      .fn()
+      .mockRejectedValue(new TypeError('Failed to fetch'));
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new TypeError('Failed to fetch')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    const id = result.current.offlineActions[0].id;
+    await act(async () => {
+      await result.current.confirmOfflineAction(id);
+    });
+    expect(result.current.error).toEqual({
+      message: 'Approved — PR #851',
+      reason: 'Still offline — action is still held in the queue',
+    });
+    expect(result.current.offlineActions).toHaveLength(1);
+  });
+
+  it('surfaces a server rejection from confirmOfflineAction as an error and removes the action', async () => {
+    const fetchMock = jest.fn(async () => ({
+      ok: false,
+      status: 422,
+      text: async () => 'review cannot be requested',
+    }));
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new TypeError('Failed to fetch')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    const id = result.current.offlineActions[0].id;
+    await act(async () => {
+      await result.current.confirmOfflineAction(id);
+    });
+    expect(result.current.error).not.toBeNull();
+    expect(result.current.offlineActions).toHaveLength(0);
+  });
+
+  it('generates a stable action id in non-secure contexts where crypto.randomUUID is unavailable', async () => {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(
+      crypto,
+      'randomUUID',
+    );
+    Object.defineProperty(crypto, 'randomUUID', {
+      value: undefined,
+      configurable: true,
+    });
+    try {
+      const { result } = renderHook(() => useConsoleActionQueue());
+      const action = makeAction({
+        commit: jest
+          .fn<Promise<void>, []>()
+          .mockRejectedValue(new TypeError('Failed to fetch')),
+        offline: offlinePayload,
+      });
+      act(() => {
+        result.current.enqueue(action);
+      });
+      await act(async () => {
+        jest.advanceTimersByTime(5000);
+        await flushMicrotasks();
+      });
+      expect(result.current.offlineActions).toHaveLength(1);
+      expect(typeof result.current.offlineActions[0].id).toBe('string');
+      expect(result.current.offlineActions[0].id.length).toBeGreaterThan(0);
+    } finally {
+      if (originalDescriptor !== undefined) {
+        Object.defineProperty(crypto, 'randomUUID', originalDescriptor);
+      }
+    }
+  });
+
+  it('skips malformed entries when loading the offline queue from localStorage', () => {
+    const malformed = [
+      { id: 'a', message: 'ok' },
+      {
+        id: 'b',
+        message: 'valid',
+        color: 'green',
+        enqueuedAt: 1,
+        itemUrl: 'https://github.com/o/r/pull/1',
+        projectItemId: 'PVTI_1',
+        itemNumber: 1,
+        repo: 'o/r',
+        isPr: true,
+        apiPath: '/api/review',
+        requestBody: { action: 'approve' },
+      },
+      null,
+    ];
+    localStorage.setItem(OFFLINE_QUEUE_STORAGE_KEY, JSON.stringify(malformed));
+    const { result } = renderHook(() => useConsoleActionQueue());
+    expect(result.current.offlineActions).toHaveLength(1);
+    expect(result.current.offlineActions[0].id).toBe('b');
+  });
+
+  it('removes the action from localStorage when discardOfflineAction is called', async () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new TypeError('Failed to fetch')),
+      offline: offlinePayload,
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    const id = result.current.offlineActions[0].id;
+    act(() => {
+      result.current.discardOfflineAction(id);
+    });
+    expect(result.current.offlineActions).toHaveLength(0);
+    const stored: unknown[] = JSON.parse(
+      localStorage.getItem(OFFLINE_QUEUE_STORAGE_KEY) ?? '[]',
+    );
+    expect(stored).toHaveLength(0);
+  });
 });

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

@@ -1,14 +1,33 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { postConsoleOperation } from '../lib/consoleApi';
 import {
   ACTION_TOAST_DELAY_MS,
   type ConsoleToastColor,
 } from '../logic/actionToast';
 
+export type ConsoleOfflinePayload = {
+  itemUrl: string;
+  projectItemId: string;
+  itemNumber: number;
+  repo: string;
+  isPr: boolean;
+  apiPath: string;
+  requestBody: Record<string, unknown>;
+};
+
+export type ConsoleOfflineQueuedAction = {
+  id: string;
+  message: string;
+  color: ConsoleToastColor;
+  enqueuedAt: number;
+} & ConsoleOfflinePayload;
+
 export type ConsoleQueuedAction = {
   message: string;
   color: ConsoleToastColor;
   commit: () => Promise<void>;
   advance: () => void;
+  offline?: ConsoleOfflinePayload;
 };
 
 export type ConsolePendingActionView = {
@@ -23,6 +42,57 @@ export type ConsoleActionError = {
   reason: string;
 };
 
+const OFFLINE_QUEUE_STORAGE_KEY = 'console-offline-action-queue';
+
+const isConsoleOfflineQueuedAction = (
+  item: unknown,
+): item is ConsoleOfflineQueuedAction => {
+  if (typeof item !== 'object' || item === null) return false;
+  const a = item as Record<string, unknown>;
+  return (
+    typeof a.id === 'string' &&
+    typeof a.message === 'string' &&
+    typeof a.color === 'string' &&
+    typeof a.enqueuedAt === 'number' &&
+    typeof a.itemUrl === 'string' &&
+    typeof a.projectItemId === 'string' &&
+    typeof a.itemNumber === 'number' &&
+    typeof a.repo === 'string' &&
+    typeof a.isPr === 'boolean' &&
+    typeof a.apiPath === 'string' &&
+    typeof a.requestBody === 'object' &&
+    a.requestBody !== null
+  );
+};
+
+const loadOfflineQueue = (): ConsoleOfflineQueuedAction[] => {
+  try {
+    const raw = localStorage.getItem(OFFLINE_QUEUE_STORAGE_KEY);
+    if (raw === null) return [];
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isConsoleOfflineQueuedAction);
+  } catch {
+    return [];
+  }
+};
+
+const saveOfflineQueue = (actions: ConsoleOfflineQueuedAction[]): void => {
+  localStorage.setItem(OFFLINE_QUEUE_STORAGE_KEY, JSON.stringify(actions));
+};
+
+const generateId = (): string => {
+  if (
+    typeof crypto !== 'undefined' &&
+    typeof crypto.randomUUID === 'function'
+  ) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+};
+
+const isNetworkError = (error: unknown): boolean => error instanceof TypeError;
+
 const errorReason = (error: unknown): string => {
   if (error instanceof Error && error.message.length > 0) {
     return error.message;
@@ -41,15 +111,24 @@ const computeProgress = (elapsedMs: number): number =>
 export type ConsoleActionQueue = {
   pending: ConsolePendingActionView | null;
   error: ConsoleActionError | null;
+  offlineActions: ConsoleOfflineQueuedAction[];
   enqueue: (action: ConsoleQueuedAction) => void;
   showError: (message: string, reason: string) => void;
   undo: () => void;
   dismissError: () => void;
+  confirmOfflineAction: (id: string) => Promise<void>;
+  discardOfflineAction: (id: string) => void;
 };
 
 export const useConsoleActionQueue = (): ConsoleActionQueue => {
   const [pending, setPending] = useState<ConsolePendingActionView | null>(null);
   const [error, setError] = useState<ConsoleActionError | null>(null);
+  const [offlineActions, setOfflineActions] =
+    useState<ConsoleOfflineQueuedAction[]>(loadOfflineQueue);
+  const offlineActionsRef =
+    useRef<ConsoleOfflineQueuedAction[]>(offlineActions);
+  offlineActionsRef.current = offlineActions;
+
   const actionRef = useRef<ConsoleQueuedAction | null>(null);
   const startRef = useRef<number>(0);
   const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
@@ -62,12 +141,35 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
     }
   }, []);
 
-  const runCommit = useCallback((action: ConsoleQueuedAction): void => {
-    action.commit().catch((cause: unknown) => {
-      setError({ message: action.message, reason: errorReason(cause) });
+  const addToOfflineQueue = useCallback((action: ConsoleQueuedAction): void => {
+    if (action.offline === undefined) return;
+    const offlineAction: ConsoleOfflineQueuedAction = {
+      id: generateId(),
+      message: action.message,
+      color: action.color,
+      enqueuedAt: Date.now(),
+      ...action.offline,
+    };
+    setOfflineActions((prev) => {
+      const next = [...prev, offlineAction];
+      saveOfflineQueue(next);
+      return next;
     });
   }, []);
 
+  const runCommit = useCallback(
+    (action: ConsoleQueuedAction): void => {
+      action.commit().catch((cause: unknown) => {
+        if (isNetworkError(cause) && action.offline !== undefined) {
+          addToOfflineQueue(action);
+        } else {
+          setError({ message: action.message, reason: errorReason(cause) });
+        }
+      });
+    },
+    [addToOfflineQueue],
+  );
+
   const commitPending = useCallback((): void => {
     const action = actionRef.current;
     clearTimer();
@@ -94,6 +196,36 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
     setError({ message, reason });
   }, []);
 
+  const discardOfflineAction = useCallback((id: string): void => {
+    setOfflineActions((prev) => {
+      const next = prev.filter((a) => a.id !== id);
+      saveOfflineQueue(next);
+      return next;
+    });
+  }, []);
+
+  const confirmOfflineAction = useCallback(
+    async (id: string): Promise<void> => {
+      const action = offlineActionsRef.current.find((a) => a.id === id);
+      if (action === undefined) return;
+      try {
+        await postConsoleOperation(action.apiPath, action.requestBody);
+        discardOfflineAction(id);
+      } catch (cause: unknown) {
+        if (isNetworkError(cause)) {
+          setError({
+            message: action.message,
+            reason: 'Still offline — action is still held in the queue',
+          });
+        } else {
+          setError({ message: action.message, reason: errorReason(cause) });
+          discardOfflineAction(id);
+        }
+      }
+    },
+    [discardOfflineAction],
+  );
+
   const enqueue = useCallback(
     (action: ConsoleQueuedAction): void => {
       if (actionRef.current !== null && !committedRef.current) {
@@ -131,5 +263,15 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
 
   useEffect(() => clearTimer, [clearTimer]);
 
-  return { pending, error, enqueue, showError, undo, dismissError };
+  return {
+    pending,
+    error,
+    offlineActions,
+    enqueue,
+    showError,
+    undo,
+    dismissError,
+    confirmOfflineAction,
+    discardOfflineAction,
+  };
 };

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

@@ -76,7 +76,7 @@ export type ConsoleOperationsApi = {
   ) => Promise<void>;
 };
 
-const reviewRequest = (
+export const reviewRequest = (
   pjcode: string,
   item: ConsoleListItem,
   prUrl: string,
@@ -129,6 +129,33 @@ const reviewRequest = (
   };
 };
 
+export const buildTriageRequest = (
+  pjcode: string,
+  item: ConsoleListItem,
+  action:
+    | ConsoleNextActionDateAction
+    | ConsoleCloseAction
+    | 'set_story'
+    | 'set_status',
+  extra?: { statusName?: string; storyOptionId?: string },
+): ConsoleTriageRequest => ({
+  pjcode,
+  action,
+  issueUrl: item.url,
+  projectItemId: item.projectItemId,
+  ...(extra ?? {}),
+});
+
+export const buildIntmuxRequest = (
+  pjcode: string,
+  item: ConsoleListItem,
+): ConsoleIntmuxRequest => ({
+  pjcode,
+  action: 'set_intmux',
+  issueUrl: item.url,
+  projectItemId: item.projectItemId,
+});
+
 const missingPjcodeError = (): Error =>
   new Error('No project specified in the URL path.');
 

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.ts

@@ -293,9 +293,9 @@ const readOperationErrorReason = async (
   return raw;
 };
 
-export const postConsoleOperation = async (
+export const postConsoleOperation = async <T extends Record<string, unknown>>(
   apiPath: string,
-  body: ConsoleReviewRequest | ConsoleTriageRequest | ConsoleIntmuxRequest,
+  body: T,
 ): Promise<void> => {
   const response = await fetch(apiPath, {
     method: 'POST',