github-issue-tower-defence-management 1.142.3 → 1.143.1

package/src/adapter/entry-points/console/ui/src/features/console/components/shared/ConsoleClipboardCopyButton.tsx

@@ -0,0 +1,57 @@
+import { useEffect, useRef, useState } from 'react';
+import { Button } from '@/components/ui/button';
+
+export type ConsoleClipboardCopyButtonProps = {
+  value: string;
+  idleText: string;
+  idleAriaLabel: string;
+  copiedAriaLabel: string;
+  className: string;
+};
+
+const COPIED_FEEDBACK_MS = 1500;
+
+export const ConsoleClipboardCopyButton = ({
+  value,
+  idleText,
+  idleAriaLabel,
+  copiedAriaLabel,
+  className,
+}: ConsoleClipboardCopyButtonProps) => {
+  const [copied, setCopied] = useState(false);
+  const resetTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(
+    () => () => {
+      if (resetTimerRef.current !== null) {
+        clearTimeout(resetTimerRef.current);
+      }
+    },
+    [],
+  );
+
+  const handleCopy = async () => {
+    await navigator.clipboard.writeText(value);
+    setCopied(true);
+    if (resetTimerRef.current !== null) {
+      clearTimeout(resetTimerRef.current);
+    }
+    resetTimerRef.current = setTimeout(() => {
+      setCopied(false);
+      resetTimerRef.current = null;
+    }, COPIED_FEEDBACK_MS);
+  };
+
+  return (
+    <Button
+      type="button"
+      variant="ghost"
+      size="sm"
+      className={className}
+      aria-label={copied ? copiedAriaLabel : idleAriaLabel}
+      onClick={handleCopy}
+    >
+      {copied ? 'Copied' : idleText}
+    </Button>
+  );
+};

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

@@ -2,6 +2,7 @@ import {
   countPendingItems,
   filterPendingItems,
   isOverlayEntryActed,
+  overlayEntriesActedSinceSnapshot,
   overlayKeyForItem,
   overlayStorageKey,
   writeOverlayEntry,
@@ -149,6 +150,60 @@ describe('workflow-blocker items are filtered by the done overlay like every oth
   });
 });
 
+describe('overlayEntriesActedSinceSnapshot', () => {
+  it('drops an entry written before the snapshot was generated so the item is pending again', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: {
+        ts: Date.parse('2026-08-04T00:20:00.000Z'),
+        mode: 'todo-by-human',
+        done: true,
+      },
+    };
+    const acted = overlayEntriesActedSinceSnapshot(
+      overlay,
+      '2026-08-04T00:26:06Z',
+    );
+    expect(acted).toEqual({});
+    expect(countPendingItems([item(1)], acted)).toBe(1);
+    expect(filterPendingItems([item(1)], acted)).toEqual([item(1)]);
+  });
+
+  it('keeps an entry written after the snapshot was generated so the item stays hidden', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: {
+        ts: Date.parse('2026-08-04T00:30:00.000Z'),
+        mode: 'todo-by-human',
+        done: true,
+      },
+    };
+    const acted = overlayEntriesActedSinceSnapshot(
+      overlay,
+      '2026-08-04T00:26:06Z',
+    );
+    expect(countPendingItems([item(1)], acted)).toBe(0);
+  });
+
+  it('keeps an entry written at the exact snapshot generation time', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: {
+        ts: Date.parse('2026-08-04T00:26:06Z'),
+        mode: 'todo-by-human',
+        done: true,
+      },
+    };
+    expect(
+      overlayEntriesActedSinceSnapshot(overlay, '2026-08-04T00:26:06Z'),
+    ).toEqual(overlay);
+  });
+
+  it('suppresses nothing when the snapshot carries no parsable generation time', () => {
+    const overlay: ConsoleOverlay = {
+      PVTI_1: { ts: 500, mode: 'todo-by-human', done: true },
+    };
+    expect(overlayEntriesActedSinceSnapshot(overlay, '')).toEqual({});
+  });
+});
+
 describe('writeOverlayEntry', () => {
   it('stamps the timestamp and mode on write', () => {
     const next = writeOverlayEntry({}, 'PVTI_1', { done: true }, 'prs', 1234);

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

@@ -30,6 +30,23 @@ export const filterPendingItems = (
     (item) => !isOverlayEntryActed(overlay[overlayKeyForItem(item)]),
   );
 
+export const overlayEntriesActedSinceSnapshot = (
+  overlay: ConsoleOverlay,
+  snapshotGeneratedAt: string,
+): ConsoleOverlay => {
+  const snapshotGeneratedAtMs = Date.parse(snapshotGeneratedAt);
+  if (Number.isNaN(snapshotGeneratedAtMs)) {
+    return {};
+  }
+  const acted: ConsoleOverlay = {};
+  for (const [key, entry] of Object.entries(overlay)) {
+    if (entry.ts >= snapshotGeneratedAtMs) {
+      acted[key] = entry;
+    }
+  }
+  return acted;
+};
+
 export const writeOverlayEntry = (
   overlay: ConsoleOverlay,
   key: string,

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

@@ -310,7 +310,11 @@ describe('ConsolePage', () => {
     localStorage.setItem(
       'pv_overlay_umino',
       JSON.stringify({
-        PVTI_B1: { ts: 1, mode: 'workflow-blocker', done: true },
+        PVTI_B1: {
+          ts: Date.parse('2026-06-19T00:05:00.000Z'),
+          mode: 'workflow-blocker',
+          done: true,
+        },
       }),
     );
     window.history.replaceState(
@@ -333,6 +337,69 @@ describe('ConsolePage', () => {
     );
   });
 
+  it('lists an item again when the overlay marked it done before the served snapshot was generated', async () => {
+    const blockerItems = [
+      {
+        number: 701,
+        title: 'Blocked deployment task',
+        url: 'https://github.com/o/r/issues/701',
+        repo: 'o/r',
+        nameWithOwner: 'o/r',
+        projectItemId: 'PVTI_B1',
+        itemId: 'PVTI_B1',
+        isPr: false,
+        story: 'TDPM Console port',
+        status: 'In Progress',
+        nextActionDate: null,
+        nextActionHour: null,
+        dependedIssueUrls: [],
+        labels: [],
+        createdAt: '2026-06-17T00:00:00.000Z',
+      },
+    ];
+    const fetchMock = jest.fn(async (url: string) => {
+      const listMatch = url.match(/\/projects\/[^/]+\/([^/]+)\/list\.json/);
+      if (listMatch !== null) {
+        return {
+          ok: true,
+          status: 200,
+          json: async () =>
+            listMatch[1] === 'workflow-blocker'
+              ? { ...listPayload('workflow-blocker'), items: blockerItems }
+              : listPayload(listMatch[1]),
+        };
+      }
+      return { ok: true, status: 200, json: async () => ({ body: '# body' }) };
+    });
+    global.fetch = fetchMock as unknown as typeof fetch;
+    localStorage.setItem(
+      'pv_overlay_umino',
+      JSON.stringify({
+        PVTI_B1: {
+          ts: Date.parse('2026-06-18T23:00:00.000Z'),
+          mode: 'workflow-blocker',
+          done: true,
+        },
+      }),
+    );
+    window.history.replaceState(
+      {},
+      '',
+      '/projects/umino/workflow-blocker?k=token',
+    );
+
+    const { getByText } = render(<ConsolePage />);
+    await waitFor(() => {
+      expect(getByText('Blocked deployment task')).toBeInTheDocument();
+    });
+    const blockerTab = within(tabBar())
+      .getByText('Workflow Blocker')
+      .closest('a');
+    expect(blockerTab?.querySelector('.console-tab-badge')?.textContent).toBe(
+      '1',
+    );
+  });
+
   it('renders the failure toast in English without any Japanese characters', async () => {
     const fetchMock = jest.fn(
       async (url: string, init?: { method?: string }) => {

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

@@ -28,6 +28,7 @@ import {
 import {
   countPendingItems,
   filterPendingItems,
+  overlayEntriesActedSinceSnapshot,
   overlayKeyForItem,
 } from '../logic/overlay';
 import type { ConsoleSwipeDirection } from '../logic/swipe';
@@ -67,7 +68,10 @@ export const ConsolePage = () => {
       }
       result[tab.name] = countPendingItems(
         snapshot.items,
-        overlayState.overlay,
+        overlayEntriesActedSinceSnapshot(
+          overlayState.overlay,
+          snapshot.generatedAt,
+        ),
       );
     }
     return result;
@@ -92,7 +96,13 @@ export const ConsolePage = () => {
     if (activeSnapshot === null) {
       return [];
     }
-    return filterPendingItems(activeSnapshot.items, overlayState.overlay);
+    return filterPendingItems(
+      activeSnapshot.items,
+      overlayEntriesActedSinceSnapshot(
+        overlayState.overlay,
+        activeSnapshot.generatedAt,
+      ),
+    );
   }, [activeSnapshot, overlayState.overlay]);
 
   const orderedPendingKeys = useMemo(

package/src/adapter/entry-points/console/ui/src/index.css

@@ -511,6 +511,37 @@ body {
   font-size: inherit;
 }
 
+.console-markdown-code-block {
+  display: flex;
+  flex-direction: column;
+  margin: 0.5em 0;
+}
+
+.console-markdown-code-block pre {
+  margin: 0;
+}
+
+.console-markdown-code-copy-host {
+  display: flex;
+  justify-content: flex-end;
+  margin-bottom: 4px;
+}
+
+.console-copy-code-button {
+  height: 24px;
+  padding: 0 8px;
+  border: 1px solid #30363d;
+  border-radius: 6px;
+  background-color: #161b22;
+  color: #c9d1d9;
+  font-size: 0.75rem;
+}
+
+.console-copy-code-button:hover {
+  background-color: #21262d;
+  color: #e6edf3;
+}
+
 .console-markdown blockquote {
   border-left: 3px solid #30363d;
   padding: 0 1em;