npm - github-issue-tower-defence-management - Versions diffs - 1.101.7 → 1.102.0 - Mend

github-issue-tower-defence-management 1.101.7 → 1.102.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/bin/adapter/entry-points/console/ui-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index--7aFZNg9.js"></script>
+    <script type="module" crossorigin src="/assets/index-CFGeqgfE.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-ES6SLB1Y.css">
   </head>
   <body>

package/jest.config.js CHANGED Viewed

@@ -57,8 +57,22 @@ module.exports = {
             },
           },
         ],
+        '^.+\\.js$': [
+          'ts-jest',
+          {
+            tsconfig: {
+              allowJs: true,
+              esModuleInterop: true,
+              module: 'CommonJS',
+              moduleResolution: 'Node',
+              verbatimModuleSyntax: false,
+            },
+          },
+        ],
       },
-      transformIgnorePatterns: ['/node_modules/(?!(marked)/)'],
+      transformIgnorePatterns: [
+        '/node_modules/(?!(marked|marked-emoji|gemoji)/)',
+      ],
       moduleNameMapper: {
         '\\.(css|less|scss)$': '<rootDir>/jest.styleMock.js',
         '^@/(.*)$': '<rootDir>/src/$1',

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "github-issue-tower-defence-management",
-  "version": "1.101.7",
+  "version": "1.102.0",
   "description": "",
   "main": "bin/index.js",
   "scripts": {
@@ -101,9 +101,11 @@
     "commander": "^14.0.0",
     "dompurify": "3.4.11",
     "dotenv": "^17.0.0",
+    "gemoji": "8.1.0",
     "googleapis": "^171.4.0",
     "ky": "^2.0.0",
     "marked": "12.0.2",
+    "marked-emoji": "2.0.3",
     "typia": "^12.0.0",
     "yaml": "^2.6.0"
   }

package/src/adapter/entry-points/console/consoleServer.test.ts CHANGED Viewed

@@ -652,6 +652,49 @@ describe('consoleServer new routes integration', () => {
     }
   });
+  it('returns 502 with the underlying error message when an operation rejects', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const issueRepository = mock<IssueRepository>();
+    issueRepository.get.mockResolvedValue({
+      ...mock<Issue>(),
+      itemId: 'PVTI_loaded',
+    });
+    issueRepository.approvePullRequest.mockRejectedValue(
+      new Error('Failed to approve PR https://github.com/o/r/pull/1: HTTP 422'),
+    );
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'ui-dist'),
+      consoleDataOutputDir: null,
+      inTmuxDataDir: null,
+      dashboardDir: null,
+      issueRepository,
+      resolveProject: async (pjcode) =>
+        pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
+      port: 0,
+    });
+    try {
+      const response = await request(
+        server,
+        'POST',
+        `/api/review?k=${testToken}`,
+        {
+          pjcode: 'umino',
+          action: 'approve',
+          prUrl: 'https://github.com/o/r/pull/1',
+          projectItemId: 'PVTI_op',
+        },
+      );
+      expect(response.statusCode).toBe(502);
+      expect(JSON.parse(response.body)).toEqual({
+        error: 'Failed to approve PR https://github.com/o/r/pull/1: HTTP 422',
+      });
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
   it('rejects an operation api with a malformed json body', async () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
     const issueRepository = mock<IssueRepository>();

package/src/adapter/entry-points/console/consoleServer.ts CHANGED Viewed

@@ -372,6 +372,32 @@ const handleReadApi = async (
   }
 };
+const operationErrorMessage = (error: unknown): string => {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  return String(error);
+};
+const dispatchOperation = (
+  context: ConsoleOperationContext,
+  requestPath: string,
+  body: Record<string, unknown>,
+): Promise<{ statusCode: number; body: unknown }> | null => {
+  switch (requestPath) {
+    case '/api/review':
+      return handleReview(context, body);
+    case '/api/triage':
+      return handleTriage(context, body);
+    case '/api/intmux':
+      return handleIntmux(context, body);
+    case '/api/comment':
+      return handleComment(context, body);
+    default:
+      return null;
+  }
+};
 const handleOperationApi = async (
   options: ConsoleServerOptions,
   requestPath: string,
@@ -387,17 +413,18 @@ const handleOperationApi = async (
     resolveProject,
     consoleDataOutputDir: options.consoleDataOutputDir,
   };
-  switch (requestPath) {
-    case '/api/review':
-      return handleReview(context, body);
-    case '/api/triage':
-      return handleTriage(context, body);
-    case '/api/intmux':
-      return handleIntmux(context, body);
-    case '/api/comment':
-      return handleComment(context, body);
-    default:
-      return null;
+  const dispatched = dispatchOperation(context, requestPath, body);
+  if (dispatched === null) {
+    return null;
+  }
+  try {
+    return await dispatched;
+  } catch (error) {
+    console.error('console operation failed', error);
+    return {
+      statusCode: 502,
+      body: { error: operationErrorMessage(error) },
+    };
   }
 };

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleErrorToast.stories.tsx ADDED Viewed

@@ -0,0 +1,23 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { ConsoleErrorToast } from './ConsoleUndoToast';
+const meta: Meta<typeof ConsoleErrorToast> = {
+  title: 'Console/ConsoleErrorToast',
+  component: ConsoleErrorToast,
+  args: {
+    message: '操作に失敗しました: HTTP 422 Review cannot be requested',
+    onDismiss: () => {},
+  },
+};
+export default meta;
+type Story = StoryObj<typeof ConsoleErrorToast>;
+export const ReviewRejectedByGitHub: Story = {};
+export const NetworkFailure: Story = {
+  args: {
+    message: '操作に失敗しました: network down',
+  },
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleUndoToast.test.tsx CHANGED Viewed

@@ -1,5 +1,5 @@
 import { fireEvent, render } from '@testing-library/react';
-import { ConsoleUndoToast } from './ConsoleUndoToast';
+import { ConsoleErrorToast, ConsoleUndoToast } from './ConsoleUndoToast';
 describe('ConsoleUndoToast', () => {
   const baseProps = {
@@ -52,3 +52,46 @@ describe('ConsoleUndoToast', () => {
     expect(onUndo).toHaveBeenCalledTimes(1);
   });
 });
+describe('ConsoleErrorToast', () => {
+  it('shows the failure message with the error modifier class and alert role', () => {
+    const { getByText, container, getByRole } = render(
+      <ConsoleErrorToast
+        message="操作に失敗しました: HTTP 422"
+        onDismiss={() => {}}
+      />,
+    );
+    expect(getByText('操作に失敗しました: HTTP 422')).toBeInTheDocument();
+    expect(
+      container.querySelector('.console-undo-toast-error'),
+    ).toBeInTheDocument();
+    expect(getByRole('alert')).toBeInTheDocument();
+  });
+  it('does not render a countdown or progress bar', () => {
+    const { container } = render(
+      <ConsoleErrorToast
+        message="操作に失敗しました: boom"
+        onDismiss={() => {}}
+      />,
+    );
+    expect(
+      container.querySelector('.console-undo-toast-countdown'),
+    ).not.toBeInTheDocument();
+    expect(
+      container.querySelector('.console-undo-toast-bar'),
+    ).not.toBeInTheDocument();
+  });
+  it('invokes onDismiss when the Dismiss control is clicked', () => {
+    const onDismiss = jest.fn();
+    const { getByText } = render(
+      <ConsoleErrorToast
+        message="操作に失敗しました: boom"
+        onDismiss={onDismiss}
+      />,
+    );
+    fireEvent.click(getByText('Dismiss'));
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/operations/ConsoleUndoToast.tsx CHANGED Viewed

@@ -34,3 +34,28 @@ export const ConsoleUndoToast = ({
     />
   </div>
 );
+export type ConsoleErrorToastProps = {
+  message: string;
+  onDismiss: () => void;
+};
+export const ConsoleErrorToast = ({
+  message,
+  onDismiss,
+}: ConsoleErrorToastProps) => (
+  <div
+    className="console-undo-toast console-undo-toast-error"
+    role="alert"
+    aria-live="assertive"
+  >
+    <span className="console-undo-toast-message">{message}</span>
+    <button
+      type="button"
+      className="console-undo-toast-undo"
+      onClick={onDismiss}
+    >
+      Dismiss
+    </button>
+  </div>
+);

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

@@ -8,11 +8,14 @@ const makeAction = (
 ) => ({
   message: 'Approved — PR #851',
   color: 'green' as const,
-  commit: jest.fn(),
+  commit: jest.fn<Promise<void>, []>().mockResolvedValue(undefined),
   advance: jest.fn(),
   ...overrides,
 });
+const flushMicrotasks = (): Promise<void> =>
+  Promise.resolve().then(() => undefined);
 describe('useConsoleActionQueue', () => {
   beforeEach(() => {
     jest.useFakeTimers();
@@ -114,4 +117,84 @@ describe('useConsoleActionQueue', () => {
     expect(first.commit).toHaveBeenCalledTimes(1);
     expect(second.commit).toHaveBeenCalledTimes(1);
   });
+  it('surfaces the failure reason when the timer commit rejects', async () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new Error('HTTP 422 review cannot be requested')),
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    expect(result.current.error).toBeNull();
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    expect(action.commit).toHaveBeenCalledTimes(1);
+    expect(result.current.error).toEqual({
+      message: 'Approved — PR #851',
+      reason: 'HTTP 422 review cannot be requested',
+    });
+  });
+  it('surfaces the failure reason when the previous action commit rejects on enqueue', async () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const first = makeAction({
+      commit: jest
+        .fn<Promise<void>, []>()
+        .mockRejectedValue(new Error('network down')),
+    });
+    const second = makeAction({
+      message: 'Rejected — PR #853',
+      color: 'amber',
+    });
+    act(() => {
+      result.current.enqueue(first);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(1000);
+      result.current.enqueue(second);
+      await flushMicrotasks();
+    });
+    expect(first.commit).toHaveBeenCalledTimes(1);
+    expect(result.current.error).toEqual({
+      message: 'Approved — PR #851',
+      reason: 'network down',
+    });
+  });
+  it('clears the surfaced error when dismissError is called', async () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction({
+      commit: jest.fn<Promise<void>, []>().mockRejectedValue(new Error('boom')),
+    });
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    expect(result.current.error).not.toBeNull();
+    act(() => {
+      result.current.dismissError();
+    });
+    expect(result.current.error).toBeNull();
+  });
+  it('does not surface an error when the commit resolves', async () => {
+    const { result } = renderHook(() => useConsoleActionQueue());
+    const action = makeAction();
+    act(() => {
+      result.current.enqueue(action);
+    });
+    await act(async () => {
+      jest.advanceTimersByTime(5000);
+      await flushMicrotasks();
+    });
+    expect(result.current.error).toBeNull();
+  });
 });

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

@@ -7,7 +7,7 @@ import {
 export type ConsoleQueuedAction = {
   message: string;
   color: ConsoleToastColor;
-  commit: () => void;
+  commit: () => Promise<void>;
   advance: () => void;
 };
@@ -18,6 +18,18 @@ export type ConsolePendingActionView = {
   progress: number;
 };
+export type ConsoleActionError = {
+  message: string;
+  reason: string;
+};
+const errorReason = (error: unknown): string => {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  return String(error);
+};
 const COUNTDOWN_TICK_MS = 100;
 const computeRemainingSeconds = (elapsedMs: number): number =>
@@ -28,12 +40,15 @@ const computeProgress = (elapsedMs: number): number =>
 export type ConsoleActionQueue = {
   pending: ConsolePendingActionView | null;
+  error: ConsoleActionError | null;
   enqueue: (action: ConsoleQueuedAction) => void;
   undo: () => void;
+  dismissError: () => void;
 };
 export const useConsoleActionQueue = (): ConsoleActionQueue => {
   const [pending, setPending] = useState<ConsolePendingActionView | null>(null);
+  const [error, setError] = useState<ConsoleActionError | null>(null);
   const actionRef = useRef<ConsoleQueuedAction | null>(null);
   const startRef = useRef<number>(0);
   const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
@@ -46,6 +61,12 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
     }
   }, []);
+  const runCommit = useCallback((action: ConsoleQueuedAction): void => {
+    action.commit().catch((cause: unknown) => {
+      setError({ message: action.message, reason: errorReason(cause) });
+    });
+  }, []);
   const commitPending = useCallback((): void => {
     const action = actionRef.current;
     clearTimer();
@@ -53,9 +74,9 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
     setPending(null);
     if (action !== null && !committedRef.current) {
       committedRef.current = true;
-      action.commit();
+      runCommit(action);
     }
-  }, [clearTimer]);
+  }, [clearTimer, runCommit]);
   const undo = useCallback((): void => {
     clearTimer();
@@ -64,13 +85,17 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
     setPending(null);
   }, [clearTimer]);
+  const dismissError = useCallback((): void => {
+    setError(null);
+  }, []);
   const enqueue = useCallback(
     (action: ConsoleQueuedAction): void => {
       if (actionRef.current !== null && !committedRef.current) {
         const previous = actionRef.current;
         clearTimer();
         committedRef.current = true;
-        previous.commit();
+        runCommit(previous);
       }
       committedRef.current = false;
       actionRef.current = action;
@@ -96,10 +121,10 @@ export const useConsoleActionQueue = (): ConsoleActionQueue => {
         });
       }, COUNTDOWN_TICK_MS);
     },
-    [clearTimer, commitPending],
+    [clearTimer, commitPending, runCommit],
   );
   useEffect(() => clearTimer, [clearTimer]);
-  return { pending, enqueue, undo };
+  return { pending, error, enqueue, undo, dismissError };
 };

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

@@ -8,6 +8,17 @@ const mockFetchOnce = (body: unknown, ok = true): jest.Mock => {
     ok,
     status: ok ? 200 : 500,
     json: async () => body,
+    text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
+  });
+  global.fetch = fetchMock as unknown as typeof fetch;
+  return fetchMock;
+};
+const mockFetchFailureOnce = (status: number, rawBody: string): jest.Mock => {
+  const fetchMock = jest.fn().mockResolvedValue({
+    ok: false,
+    status,
+    text: async () => rawBody,
   });
   global.fetch = fetchMock as unknown as typeof fetch;
   return fetchMock;
@@ -169,15 +180,31 @@ describe('postConsoleOperation', () => {
     expect(init).toMatchObject({ method: 'POST' });
   });
-  it('throws on a failed operation', async () => {
-    mockFetchOnce({}, false);
-    await expect(
-      postConsoleOperation(appendToken, '/api/review', {
-        pjcode: 'umino',
-        action: 'approve',
-        prUrl: 'https://github.com/o/r/pull/1',
-        projectItemId: 'PVTI_1',
-      }),
-    ).rejects.toThrow('HTTP 500');
+  const failingReview = (): Promise<void> =>
+    postConsoleOperation(appendToken, '/api/review', {
+      pjcode: 'umino',
+      action: 'approve',
+      prUrl: 'https://github.com/o/r/pull/1',
+      projectItemId: 'PVTI_1',
+    });
+  it('throws the error reason from a JSON error body', async () => {
+    mockFetchFailureOnce(
+      502,
+      JSON.stringify({ error: 'Failed to approve PR: HTTP 422' }),
+    );
+    await expect(failingReview()).rejects.toThrow(
+      'Failed to approve PR: HTTP 422',
+    );
+  });
+  it('throws the raw body when the error body is not JSON', async () => {
+    mockFetchFailureOnce(500, 'Internal Server Error');
+    await expect(failingReview()).rejects.toThrow('Internal Server Error');
+  });
+  it('falls back to the status code when the error body is empty', async () => {
+    mockFetchFailureOnce(500, '');
+    await expect(failingReview()).rejects.toThrow('HTTP 500');
   });
 });

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

@@ -171,6 +171,24 @@ export const createConsoleApiClient = (
     parseState(await requestJson(appendToken, '/api/issuetitle', url)),
 });
+const readOperationErrorReason = async (
+  response: Response,
+): Promise<string> => {
+  const raw = await response.text().catch(() => '');
+  if (raw.length === 0) {
+    return `HTTP ${response.status}`;
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (isRecord(parsed) && typeof parsed.error === 'string') {
+      return parsed.error;
+    }
+  } catch {
+    return raw;
+  }
+  return raw;
+};
 export const postConsoleOperation = async (
   appendToken: AppendToken,
   apiPath: string,
@@ -182,7 +200,7 @@ export const postConsoleOperation = async (
     body: JSON.stringify(body),
   });
   if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
+    throw new Error(await readOperationErrorReason(response));
   }
 };

package/src/adapter/entry-points/console/ui/src/features/console/lib/markdown.test.ts CHANGED Viewed

@@ -44,6 +44,16 @@ describe('renderMarkdownToSafeHtml', () => {
   it('returns an empty string for blank input', () => {
     expect(renderMarkdownToSafeHtml('   ')).toBe('');
   });
+  it('renders GitHub emoji shortcodes as Unicode emoji glyphs', () => {
+    const html = renderMarkdownToSafeHtml(':magic_wand: :sparkles: :rocket:');
+    expect(html).toContain('🪄');
+    expect(html).toContain('✨');
+    expect(html).toContain('🚀');
+    expect(html).not.toContain(':magic_wand:');
+    expect(html).not.toContain(':sparkles:');
+    expect(html).not.toContain(':rocket:');
+  });
 });
 describe('splitMarkdownSegments', () => {

package/src/adapter/entry-points/console/ui/src/features/console/lib/markdown.ts CHANGED Viewed

@@ -1,5 +1,14 @@
 import DOMPurify from 'dompurify';
+import { nameToEmoji } from 'gemoji';
 import { marked } from 'marked';
+import { markedEmoji } from 'marked-emoji';
+marked.use(
+  markedEmoji({
+    emojis: nameToEmoji,
+    renderer: (token) => token.emoji,
+  }),
+);
 export const renderMarkdownToSafeHtml = (source: string): string => {
   const trimmed = source.trim();

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsoleItemDetailContainer.tsx CHANGED Viewed

@@ -22,7 +22,7 @@ import type {
 export type ConsoleQueueActionInput = {
   kind: ConsoleActionKind;
   item: ConsoleListItem;
-  commit: () => void;
+  commit: () => Promise<void>;
 };
 export type ConsoleItemDetailContainerProps = {
@@ -68,54 +68,42 @@ export const ConsoleItemDetailContainer = ({
       onQueueAction({
         kind: { type: 'review', action },
         item,
-        commit: () => {
-          void operations.reviewPullRequest(item, prUrl, action);
-        },
+        commit: () => operations.reviewPullRequest(item, prUrl, action),
       });
     },
     onSetNextActionDate: (action) => {
       onQueueAction({
         kind: { type: 'next_action_date', action },
         item,
-        commit: () => {
-          void operations.setNextActionDate(item, action);
-        },
+        commit: () => operations.setNextActionDate(item, action),
       });
     },
     onSetStory: (option: ConsoleFieldOption) => {
       onQueueAction({
         kind: { type: 'set_story', optionName: option.name },
         item,
-        commit: () => {
-          void operations.setStory(item, option);
-        },
+        commit: () => operations.setStory(item, option),
       });
     },
     onSetStatus: (option: ConsoleFieldOption) => {
       onQueueAction({
         kind: { type: 'set_status', optionName: option.name },
         item,
-        commit: () => {
-          void operations.setStatus(item, option);
-        },
+        commit: () => operations.setStatus(item, option),
       });
     },
     onSetInTmuxByHuman: (option: ConsoleFieldOption) => {
       onQueueAction({
         kind: { type: 'set_in_tmux_by_human', optionName: option.name },
         item,
-        commit: () => {
-          void operations.setInTmuxByHuman(item, option);
-        },
+        commit: () => operations.setInTmuxByHuman(item, option),
       });
     },
     onClose: (action) => {
       onQueueAction({
         kind: { type: 'close', action },
         item,
-        commit: () => {
-          void operations.closeIssue(item, action);
-        },
+        commit: () => operations.closeIssue(item, action),
       });
     },
   };