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

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

@@ -0,0 +1,401 @@
+import type {
+  ConsoleChangedFile,
+  ConsoleComment,
+  ConsoleCommit,
+  ConsoleFieldOption,
+  ConsoleIssueState,
+  ConsoleListItem,
+  ConsolePullRequestStatus,
+  ConsoleRelatedPullRequest,
+  ConsoleStoryColorSource,
+  ConsoleStoryEntry,
+  ConsoleTabName,
+} from '../logic/types';
+
+export type AirplaneTabSnapshot = {
+  items: ConsoleListItem[];
+  generatedAt: string;
+  statusOptions: ConsoleFieldOption[];
+  storyOptions: ConsoleFieldOption[];
+  storyColors: ConsoleStoryColorSource;
+  stories: ConsoleStoryEntry[];
+  defaultNameWithOwner: string | null;
+  fromCache: boolean;
+  storyOrder: string[];
+};
+
+export type AirplaneItemSnapshot = {
+  body: string;
+  comments: ConsoleComment[];
+  state: ConsoleIssueState;
+  files: ConsoleChangedFile[] | null;
+  commits: ConsoleCommit[] | null;
+  prStatus: ConsolePullRequestStatus | null;
+  relatedPrs: ConsoleRelatedPullRequest[] | null;
+};
+
+export type AirplaneSnapshot = {
+  capturedAt: string;
+  tabs: Record<string, Record<ConsoleTabName, AirplaneTabSnapshot>>;
+  items: Record<string, AirplaneItemSnapshot>;
+  failures: string[];
+};
+
+const AIRPLANE_CACHE_NAME = 'tdpm-airplane-v1';
+const AIRPLANE_SNAPSHOT_REQUEST_URL = '/airplane-snapshot-data';
+const AIRPLANE_MODE_STORAGE_KEY = 'tdpm_airplane_mode_on';
+
+export const readAirplaneModeFlag = (): boolean => {
+  if (typeof localStorage === 'undefined') {
+    return false;
+  }
+  return localStorage.getItem(AIRPLANE_MODE_STORAGE_KEY) === '1';
+};
+
+export const writeAirplaneModeFlag = (on: boolean): void => {
+  if (typeof localStorage === 'undefined') {
+    return;
+  }
+  if (on) {
+    localStorage.setItem(AIRPLANE_MODE_STORAGE_KEY, '1');
+  } else {
+    localStorage.removeItem(AIRPLANE_MODE_STORAGE_KEY);
+  }
+};
+
+export const storeAirplaneSnapshot = async (
+  snapshot: AirplaneSnapshot,
+): Promise<void> => {
+  if (typeof caches === 'undefined') {
+    throw new Error('Cache API unavailable');
+  }
+  try {
+    const cache = await caches.open(AIRPLANE_CACHE_NAME);
+    await cache.put(
+      AIRPLANE_SNAPSHOT_REQUEST_URL,
+      new Response(JSON.stringify(snapshot), {
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    );
+  } catch (err) {
+    if (err instanceof Error && err.name === 'QuotaExceededError') {
+      throw new Error(
+        'Not enough browser storage to save the offline snapshot. Free up storage and retry.',
+      );
+    }
+    throw err;
+  }
+};
+
+export const loadAirplaneSnapshot =
+  async (): Promise<AirplaneSnapshot | null> => {
+    if (typeof caches === 'undefined') {
+      return null;
+    }
+    const cache = await caches.open(AIRPLANE_CACHE_NAME);
+    const response = await cache.match(AIRPLANE_SNAPSHOT_REQUEST_URL);
+    if (response === undefined) {
+      return null;
+    }
+    return response.json() as Promise<AirplaneSnapshot>;
+  };
+
+export const clearAirplaneSnapshot = async (): Promise<void> => {
+  if (typeof caches === 'undefined') {
+    return;
+  }
+  await caches.delete(AIRPLANE_CACHE_NAME);
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const getString = (value: unknown): string =>
+  typeof value === 'string' ? value : '';
+
+const getNumber = (value: unknown): number =>
+  typeof value === 'number' ? value : 0;
+
+const getBoolean = (value: unknown): boolean => value === true;
+
+const parseStringArray = (value: unknown): string[] =>
+  Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === 'string')
+    : [];
+
+const parseMergeableStatus = (
+  value: unknown,
+): 'MERGEABLE' | 'CONFLICTING' | 'UNKNOWN' => {
+  if (value === 'MERGEABLE') {
+    return 'MERGEABLE';
+  }
+  if (value === 'CONFLICTING') {
+    return 'CONFLICTING';
+  }
+  return 'UNKNOWN';
+};
+
+const parseListItem = (item: unknown): ConsoleListItem | null => {
+  if (!isRecord(item)) {
+    return null;
+  }
+  return {
+    number: getNumber(item.number),
+    title: getString(item.title),
+    url: getString(item.url),
+    repo: getString(item.repo),
+    nameWithOwner: getString(item.nameWithOwner),
+    projectItemId: getString(item.projectItemId),
+    itemId: getString(item.itemId),
+    isPr: getBoolean(item.isPr),
+    story: getString(item.story),
+    status: typeof item.status === 'string' ? item.status : null,
+    nextActionDate:
+      typeof item.nextActionDate === 'string' ? item.nextActionDate : null,
+    nextActionHour:
+      typeof item.nextActionHour === 'number' ? item.nextActionHour : null,
+    dependedIssueUrls: parseStringArray(item.dependedIssueUrls),
+    labels: parseStringArray(item.labels),
+    createdAt: getString(item.createdAt),
+    relatedOpenPullRequestUrls: parseStringArray(
+      item.relatedOpenPullRequestUrls,
+    ),
+    agent: typeof item.agent === 'string' ? item.agent : null,
+  };
+};
+
+const parseTabSnapshot = (payload: unknown): AirplaneTabSnapshot => {
+  if (!isRecord(payload)) {
+    return {
+      items: [],
+      generatedAt: '',
+      statusOptions: [],
+      storyOptions: [],
+      storyColors: {},
+      stories: [],
+      defaultNameWithOwner: null,
+      fromCache: false,
+      storyOrder: [],
+    };
+  }
+  const items: ConsoleListItem[] = Array.isArray(payload.items)
+    ? payload.items
+        .map(parseListItem)
+        .filter((item): item is ConsoleListItem => item !== null)
+    : [];
+  const statusOptions: ConsoleFieldOption[] = Array.isArray(
+    payload.statusOptions,
+  )
+    ? (payload.statusOptions.filter(isRecord) as ConsoleFieldOption[])
+    : [];
+  const storyOptions: ConsoleFieldOption[] = Array.isArray(payload.storyOptions)
+    ? (payload.storyOptions.filter(isRecord) as ConsoleFieldOption[])
+    : [];
+  const stories: ConsoleStoryEntry[] = Array.isArray(payload.stories)
+    ? (payload.stories.filter(isRecord) as unknown as ConsoleStoryEntry[])
+    : [];
+  const storyOrder: string[] = Array.isArray(payload.storyOrder)
+    ? payload.storyOrder.filter((s): s is string => typeof s === 'string')
+    : [];
+  return {
+    items,
+    generatedAt:
+      typeof payload.generatedAt === 'string' ? payload.generatedAt : '',
+    statusOptions,
+    storyOptions,
+    storyColors: isRecord(payload.storyColors)
+      ? (payload.storyColors as ConsoleStoryColorSource)
+      : {},
+    stories,
+    defaultNameWithOwner:
+      typeof payload.defaultNameWithOwner === 'string'
+        ? payload.defaultNameWithOwner
+        : null,
+    fromCache: false,
+    storyOrder,
+  };
+};
+
+const parseComment = (item: unknown): ConsoleComment | null => {
+  if (!isRecord(item)) {
+    return null;
+  }
+  return {
+    author: getString(item.author),
+    body: getString(item.body),
+    createdAt: getString(item.createdAt),
+  };
+};
+
+const parseChangedFile = (item: unknown): ConsoleChangedFile | null => {
+  if (!isRecord(item)) {
+    return null;
+  }
+  return {
+    path: getString(item.path),
+    additions: getNumber(item.additions),
+    deletions: getNumber(item.deletions),
+    status: getString(item.status),
+    patch: typeof item.patch === 'string' ? item.patch : null,
+    rawUrl: typeof item.rawUrl === 'string' ? item.rawUrl : null,
+  };
+};
+
+const parseCommit = (item: unknown): ConsoleCommit | null => {
+  if (!isRecord(item)) {
+    return null;
+  }
+  return {
+    sha: getString(item.sha),
+    message: getString(item.message),
+    author: getString(item.author),
+    authoredAt: getString(item.authoredAt),
+  };
+};
+
+const parsePrStatus = (item: unknown): ConsolePullRequestStatus => {
+  if (!isRecord(item)) {
+    return {
+      found: false,
+      isConflicted: false,
+      mergeableStatus: 'UNKNOWN',
+      isPassedAllCiJob: false,
+      isCiStateSuccess: false,
+      isBranchOutOfDate: false,
+      missingRequiredCheckNames: [],
+    };
+  }
+  return {
+    found: getBoolean(item.found),
+    isConflicted: getBoolean(item.isConflicted),
+    mergeableStatus: parseMergeableStatus(item.mergeableStatus),
+    isPassedAllCiJob: getBoolean(item.isPassedAllCiJob),
+    isCiStateSuccess: getBoolean(item.isCiStateSuccess),
+    isBranchOutOfDate: getBoolean(item.isBranchOutOfDate),
+    missingRequiredCheckNames: parseStringArray(item.missingRequiredCheckNames),
+  };
+};
+
+const parseRelatedPr = (item: unknown): ConsoleRelatedPullRequest | null => {
+  if (!isRecord(item)) {
+    return null;
+  }
+  const summary = isRecord(item.summary)
+    ? {
+        title: getString(item.summary.title),
+        body: getString(item.summary.body),
+        additions: getNumber(item.summary.additions),
+        deletions: getNumber(item.summary.deletions),
+        changedFiles: getNumber(item.summary.changedFiles),
+      }
+    : null;
+  return {
+    url: getString(item.url),
+    branchName: typeof item.branchName === 'string' ? item.branchName : null,
+    createdAt: getString(item.createdAt),
+    isDraft: getBoolean(item.isDraft),
+    isConflicted: getBoolean(item.isConflicted),
+    mergeableStatus: parseMergeableStatus(item.mergeableStatus),
+    isPassedAllCiJob: getBoolean(item.isPassedAllCiJob),
+    isCiStateSuccess: getBoolean(item.isCiStateSuccess),
+    isResolvedAllReviewComments: getBoolean(item.isResolvedAllReviewComments),
+    isBranchOutOfDate: getBoolean(item.isBranchOutOfDate),
+    missingRequiredCheckNames: parseStringArray(item.missingRequiredCheckNames),
+    summary,
+  };
+};
+
+const parseItemSnapshot = (item: unknown): AirplaneItemSnapshot => {
+  if (!isRecord(item)) {
+    return {
+      body: '',
+      comments: [],
+      state: { state: 'open', merged: false, isPullRequest: false, title: '' },
+      files: null,
+      commits: null,
+      prStatus: null,
+      relatedPrs: null,
+    };
+  }
+  const stateRaw = isRecord(item.state) ? item.state : {};
+  const state: ConsoleIssueState = {
+    state: getString(stateRaw.state) || 'open',
+    merged: getBoolean(stateRaw.merged),
+    isPullRequest: getBoolean(stateRaw.isPullRequest),
+    title: getString(stateRaw.title),
+  };
+  const files =
+    item.files === null
+      ? null
+      : Array.isArray(item.files)
+        ? item.files
+            .map(parseChangedFile)
+            .filter((f): f is ConsoleChangedFile => f !== null)
+        : null;
+  const commits =
+    item.commits === null
+      ? null
+      : Array.isArray(item.commits)
+        ? item.commits
+            .map(parseCommit)
+            .filter((c): c is ConsoleCommit => c !== null)
+        : null;
+  const prStatus = item.prStatus === null ? null : parsePrStatus(item.prStatus);
+  const relatedPrs =
+    item.relatedPrs === null
+      ? null
+      : Array.isArray(item.relatedPrs)
+        ? item.relatedPrs
+            .map(parseRelatedPr)
+            .filter((pr): pr is ConsoleRelatedPullRequest => pr !== null)
+        : null;
+  return {
+    body: getString(item.body),
+    comments: Array.isArray(item.comments)
+      ? item.comments
+          .map(parseComment)
+          .filter((c): c is ConsoleComment => c !== null)
+      : [],
+    state,
+    files,
+    commits,
+    prStatus,
+    relatedPrs,
+  };
+};
+
+export const parseAirplaneSnapshot = (
+  raw: unknown,
+): AirplaneSnapshot | null => {
+  if (!isRecord(raw)) {
+    return null;
+  }
+  const capturedAt = typeof raw.capturedAt === 'string' ? raw.capturedAt : '';
+  const failures = parseStringArray(raw.failures);
+
+  const tabs: Record<string, Record<ConsoleTabName, AirplaneTabSnapshot>> = {};
+  if (isRecord(raw.tabs)) {
+    for (const [pjcode, pjTabs] of Object.entries(raw.tabs)) {
+      if (!isRecord(pjTabs)) {
+        continue;
+      }
+      const parsedPjTabs: Record<string, AirplaneTabSnapshot> = {};
+      for (const [tabName, tabPayload] of Object.entries(pjTabs)) {
+        parsedPjTabs[tabName] = parseTabSnapshot(tabPayload);
+      }
+      tabs[pjcode] = parsedPjTabs as Record<
+        ConsoleTabName,
+        AirplaneTabSnapshot
+      >;
+    }
+  }
+
+  const items: Record<string, AirplaneItemSnapshot> = {};
+  if (isRecord(raw.items)) {
+    for (const [url, itemData] of Object.entries(raw.items)) {
+      items[url] = parseItemSnapshot(itemData);
+    }
+  }
+
+  return { capturedAt, tabs, items, failures };
+};

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

@@ -51,6 +51,10 @@ export class ResourceCache<T> {
       });
   };
 
+  seed(key: string, value: T): void {
+    this.cache.set(key, value);
+  }
+
   invalidate = (key: string): void => {
     this.cache.delete(key);
   };

package/src/adapter/entry-points/console/ui/src/features/console/logic/actionToast.test.ts

@@ -72,6 +72,28 @@ describe('actionToastMessage', () => {
     );
   });
 
+  it('labels the +1 hour snooze the same on every tab', () => {
+    const kind: ConsoleActionKind = {
+      type: 'next_action_date',
+      action: 'snooze_1hour',
+    };
+    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Hour +1 hour');
+    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
+      'Next Action Hour +1 hour',
+    );
+  });
+
+  it('labels the +3 hours snooze the same on every tab', () => {
+    const kind: ConsoleActionKind = {
+      type: 'next_action_date',
+      action: 'snooze_3hours',
+    };
+    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Hour +3 hours');
+    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
+      'Next Action Hour +3 hours',
+    );
+  });
+
   it('labels close actions', () => {
     expect(actionToastMessage({ type: 'close', action: 'close' }, 'prs')).toBe(
       'Closed',

package/src/adapter/entry-points/console/ui/src/features/console/logic/actionToast.ts

@@ -45,6 +45,12 @@ export const actionToastMessage = (
       }
       return 'Marked unnecessary';
     case 'next_action_date':
+      if (kind.action === 'snooze_1hour') {
+        return 'Next Action Hour +1 hour';
+      }
+      if (kind.action === 'snooze_3hours') {
+        return 'Next Action Hour +3 hours';
+      }
       if (kind.action === 'snooze_1day') {
         return 'Next Action Date +1 day';
       }

package/src/adapter/entry-points/console/ui/src/features/console/logic/operations.ts

@@ -27,7 +27,11 @@ export type ConsoleReviewAction =
   | 'unnecessary'
   | 'totally_wrong';
 
-export type ConsoleNextActionDateAction = 'snooze_1day' | 'snooze_1week';
+export type ConsoleNextActionDateAction =
+  | 'snooze_1hour'
+  | 'snooze_3hours'
+  | 'snooze_1day'
+  | 'snooze_1week';
 
 export type ConsoleCloseAction = 'close' | 'close_not_planned';
 

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsolePage.test.tsx

@@ -30,6 +30,15 @@ const listPayload = (tab: string) => ({
   statusOptions: [{ id: 's1', name: 'Awaiting Workspace', color: 'BLUE' }],
   storyOptions: [{ id: 'st1', name: 'TDPM Console port', color: 'BLUE' }],
   storyColors: { 'TDPM Console port': { color: 'BLUE' } },
+  stories: [
+    {
+      storyName: 'TDPM Console port',
+      storyOptionId: 'st1',
+      color: 'BLUE',
+      openItemCount: 1,
+      storyViewUrl: null,
+    },
+  ],
   items:
     tab === 'prs'
       ? [
@@ -516,6 +525,30 @@ describe('ConsolePage', () => {
       jest.useRealTimers();
     }
   });
+
+  it('renders reorder buttons in the Stories tab', async () => {
+    window.history.replaceState({}, '', '/projects/acme/stories?k=token');
+    const { getAllByRole, getByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(
+        getByText('snapshot: 2026-06-19T00:00:00.000Z'),
+      ).toBeInTheDocument();
+    });
+    expect(getAllByRole('button', { name: 'Move up' }).length).toBeGreaterThan(
+      0,
+    );
+  });
+
+  it('does not render reorder buttons in the Triage tab', async () => {
+    window.history.replaceState({}, '', '/projects/acme/triage?k=token');
+    const { queryAllByRole, getByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(
+        getByText('snapshot: 2026-06-19T00:00:00.000Z'),
+      ).toBeInTheDocument();
+    });
+    expect(queryAllByRole('button', { name: 'Move up' })).toHaveLength(0);
+  });
 });
 
 const twoItemPrPayload = () => ({
@@ -1200,3 +1233,179 @@ describe('ConsolePage auto-advance tab', () => {
     }
   });
 });
+
+describe('ConsolePage airplane mode write guard', () => {
+  const prItem = {
+    number: 851,
+    title: 'Add serveConsole subcommand',
+    url: 'https://github.com/o/r/pull/851',
+    repo: 'o/r',
+    nameWithOwner: 'o/r',
+    projectItemId: 'PVTI_1',
+    itemId: 'PVTI_1',
+    isPr: true,
+    relatedOpenPullRequestUrls: [],
+    story: 'TDPM Console port',
+    status: 'Awaiting Quality Check',
+    nextActionDate: null,
+    nextActionHour: null,
+    dependedIssueUrls: [],
+    labels: [],
+    createdAt: '2026-06-17T00:00:00.000Z',
+    agent: null,
+  };
+
+  const airplaneSnapshot = {
+    capturedAt: '2026-06-19T00:00:00.000Z',
+    tabs: {
+      acme: {
+        prs: {
+          items: [prItem],
+          generatedAt: '2026-06-19T00:00:00.000Z',
+          statusOptions: [
+            { id: 's1', name: 'Awaiting Workspace', color: 'BLUE' },
+          ],
+          storyOptions: [
+            { id: 'st1', name: 'TDPM Console port', color: 'BLUE' },
+          ],
+          storyColors: { 'TDPM Console port': { color: 'BLUE' } },
+          stories: [],
+          defaultNameWithOwner: 'o/r',
+          fromCache: false,
+          storyOrder: [],
+        },
+        'workflow-blocker': {
+          items: [],
+          generatedAt: '',
+          statusOptions: [],
+          storyOptions: [],
+          storyColors: {},
+          stories: [],
+          defaultNameWithOwner: null,
+          fromCache: false,
+          storyOrder: [],
+        },
+        'failed-preparation': {
+          items: [],
+          generatedAt: '',
+          statusOptions: [],
+          storyOptions: [],
+          storyColors: {},
+          stories: [],
+          defaultNameWithOwner: null,
+          fromCache: false,
+          storyOrder: [],
+        },
+        'todo-by-human': {
+          items: [],
+          generatedAt: '',
+          statusOptions: [],
+          storyOptions: [],
+          storyColors: {},
+          stories: [],
+          defaultNameWithOwner: null,
+          fromCache: false,
+          storyOrder: [],
+        },
+        'todo-by-agent': {
+          items: [],
+          generatedAt: '',
+          statusOptions: [],
+          storyOptions: [],
+          storyColors: {},
+          stories: [],
+          defaultNameWithOwner: null,
+          fromCache: false,
+          storyOrder: [],
+        },
+        stories: {
+          items: [],
+          generatedAt: '',
+          statusOptions: [],
+          storyOptions: [],
+          storyColors: {},
+          stories: [],
+          defaultNameWithOwner: null,
+          fromCache: false,
+          storyOrder: [],
+        },
+      },
+    },
+    items: {},
+    failures: [],
+  };
+
+  beforeEach(() => {
+    localStorage.clear();
+    window.history.replaceState({}, '', '/projects/acme/prs?k=token');
+
+    localStorage.setItem('tdpm_airplane_mode_on', '1');
+
+    const snapshotJson = JSON.stringify(airplaneSnapshot);
+    const mockCache = {
+      put: jest.fn(),
+      match: jest.fn().mockResolvedValue(
+        new Response(snapshotJson, {
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      ),
+      delete: jest.fn(),
+    };
+    Object.defineProperty(global, 'caches', {
+      writable: true,
+      configurable: true,
+      value: {
+        open: jest.fn().mockResolvedValue(mockCache),
+        delete: jest.fn().mockResolvedValue(true),
+      },
+    });
+
+    global.fetch = jest.fn(async (url: string) => {
+      if (url === '/api/features') {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ airplaneMode: true }),
+        };
+      }
+      if (url === '/api/projects') {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ pjcodes: ['acme'] }),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({ body: '# body' }) };
+    }) as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    Object.defineProperty(global, 'caches', {
+      writable: true,
+      configurable: true,
+      value: undefined,
+    });
+  });
+
+  it('shows an airplane mode error toast instead of enqueuing when airplane mode is on', async () => {
+    const { getByText, findByText } = render(<ConsolePage />);
+
+    await waitFor(() => {
+      expect(getByText('Add serveConsole subcommand')).toBeInTheDocument();
+    });
+
+    await waitFor(() => {
+      expect(getByText('Turn off')).toBeInTheDocument();
+    });
+
+    fireEvent.click(getByText('Add serveConsole subcommand'));
+    expect(await findByText('Approve & Merge')).toBeInTheDocument();
+    fireEvent.click(getByText('Approve & Merge'));
+
+    await waitFor(() => {
+      expect(getByText('Airplane mode')).toBeInTheDocument();
+    });
+    expect(getByText(/network connection/i)).toBeInTheDocument();
+    expect(document.querySelector('.console-undo-toast')).toBeNull();
+  });
+});