github-issue-tower-defence-management 1.89.0 → 1.91.0

package/src/adapter/entry-points/console/consoleProjectResolver.test.ts

@@ -0,0 +1,96 @@
+import { mock } from 'jest-mock-extended';
+import { Project } from '../../../domain/entities/Project';
+import {
+  buildPjcodeToProjectUrl,
+  createConsoleProjectResolver,
+} from './consoleProjectResolver';
+
+describe('buildPjcodeToProjectUrl', () => {
+  it('adds the default pjcode entry when it is not already present', () => {
+    const mapping = buildPjcodeToProjectUrl(
+      'umino',
+      'https://github.com/orgs/umino/projects/1',
+      { xmile: 'https://github.com/orgs/xmile/projects/2' },
+    );
+    expect(mapping).toEqual({
+      umino: 'https://github.com/orgs/umino/projects/1',
+      xmile: 'https://github.com/orgs/xmile/projects/2',
+    });
+  });
+
+  it('keeps an explicit default pjcode entry from consoleProjects', () => {
+    const mapping = buildPjcodeToProjectUrl(
+      'umino',
+      'https://github.com/orgs/umino/projects/1',
+      { umino: 'https://github.com/orgs/umino/projects/9' },
+    );
+    expect(mapping.umino).toBe('https://github.com/orgs/umino/projects/9');
+  });
+
+  it('uses only the default entry when no consoleProjects mapping is configured', () => {
+    const mapping = buildPjcodeToProjectUrl(
+      'umino',
+      'https://github.com/orgs/umino/projects/1',
+      null,
+    );
+    expect(mapping).toEqual({
+      umino: 'https://github.com/orgs/umino/projects/1',
+    });
+  });
+});
+
+describe('createConsoleProjectResolver', () => {
+  const uminoProject: Project = { ...mock<Project>(), id: 'PVT_umino' };
+  const xmileProject: Project = { ...mock<Project>(), id: 'PVT_xmile' };
+
+  it('resolves a known pjcode to its loaded project', async () => {
+    const loadProject = jest.fn(async (url: string) =>
+      url.includes('umino') ? uminoProject : xmileProject,
+    );
+    const resolver = createConsoleProjectResolver(
+      {
+        umino: 'https://github.com/orgs/umino/projects/1',
+        xmile: 'https://github.com/orgs/xmile/projects/2',
+      },
+      loadProject,
+    );
+    await expect(resolver('umino')).resolves.toEqual({
+      pjcode: 'umino',
+      project: uminoProject,
+    });
+    await expect(resolver('xmile')).resolves.toEqual({
+      pjcode: 'xmile',
+      project: xmileProject,
+    });
+  });
+
+  it('returns null for a pjcode that has no configured project url', async () => {
+    const loadProject = jest.fn(async () => uminoProject);
+    const resolver = createConsoleProjectResolver(
+      { umino: 'https://github.com/orgs/umino/projects/1' },
+      loadProject,
+    );
+    await expect(resolver('unknown')).resolves.toBeNull();
+    expect(loadProject).not.toHaveBeenCalled();
+  });
+
+  it('returns null when the project fails to load', async () => {
+    const loadProject = jest.fn(async () => null);
+    const resolver = createConsoleProjectResolver(
+      { umino: 'https://github.com/orgs/umino/projects/1' },
+      loadProject,
+    );
+    await expect(resolver('umino')).resolves.toBeNull();
+  });
+
+  it('loads each project at most once and serves later calls from cache', async () => {
+    const loadProject = jest.fn(async () => uminoProject);
+    const resolver = createConsoleProjectResolver(
+      { umino: 'https://github.com/orgs/umino/projects/1' },
+      loadProject,
+    );
+    await resolver('umino');
+    await resolver('umino');
+    expect(loadProject).toHaveBeenCalledTimes(1);
+  });
+});

package/src/adapter/entry-points/console/consoleProjectResolver.ts

@@ -0,0 +1,50 @@
+import { Project } from '../../../domain/entities/Project';
+import {
+  ConsoleProjectBinding,
+  ConsoleProjectResolver,
+} from './consoleOperationApi';
+
+export type ConsoleProjectLoader = (
+  projectUrl: string,
+) => Promise<Project | null>;
+
+export const buildPjcodeToProjectUrl = (
+  defaultPjcode: string,
+  defaultProjectUrl: string,
+  consoleProjects: Record<string, string> | null,
+): Record<string, string> => {
+  const mapping: Record<string, string> = {};
+  if (consoleProjects !== null) {
+    for (const [pjcode, projectUrl] of Object.entries(consoleProjects)) {
+      mapping[pjcode] = projectUrl;
+    }
+  }
+  if (!(defaultPjcode in mapping)) {
+    mapping[defaultPjcode] = defaultProjectUrl;
+  }
+  return mapping;
+};
+
+export const createConsoleProjectResolver = (
+  pjcodeToProjectUrl: Record<string, string>,
+  loadProject: ConsoleProjectLoader,
+): ConsoleProjectResolver => {
+  const cache = new Map<string, ConsoleProjectBinding>();
+  return async (pjcode: string): Promise<ConsoleProjectBinding | null> => {
+    const cached = cache.get(pjcode);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const projectUrl = pjcodeToProjectUrl[pjcode];
+    if (projectUrl === undefined) {
+      return null;
+    }
+    const project = await loadProject(projectUrl);
+    if (project === null) {
+      return null;
+    }
+    const binding: ConsoleProjectBinding = { pjcode, project };
+    cache.set(pjcode, binding);
+    return binding;
+  };
+};

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

@@ -9,6 +9,7 @@ import {
   hasDotSegment,
   requiresToken,
   isTokenValid,
+  isConsoleAppRoute,
   extractProvidedToken,
   startConsoleServer,
 } from './consoleServer';
@@ -61,6 +62,35 @@ describe('consoleServer pure helpers', () => {
     });
   });
 
+  describe('isConsoleAppRoute', () => {
+    it('matches a per-project root route', () => {
+      expect(isConsoleAppRoute('/projects/umino')).toBe(true);
+      expect(isConsoleAppRoute('/projects/umino/')).toBe(true);
+    });
+
+    it('matches a per-project tab route for every list tab', () => {
+      expect(isConsoleAppRoute('/projects/umino/prs')).toBe(true);
+      expect(isConsoleAppRoute('/projects/xmile/triage')).toBe(true);
+      expect(isConsoleAppRoute('/projects/xcare/unread')).toBe(true);
+      expect(isConsoleAppRoute('/projects/utage3/failed-preparation')).toBe(
+        true,
+      );
+      expect(isConsoleAppRoute('/projects/utage3/todo-by-human')).toBe(true);
+    });
+
+    it('does not match data, api, or unknown tab routes', () => {
+      expect(isConsoleAppRoute('/projects/umino/prs/list.json')).toBe(false);
+      expect(isConsoleAppRoute('/projects/umino/unknown')).toBe(false);
+      expect(isConsoleAppRoute('/projects')).toBe(false);
+      expect(isConsoleAppRoute('/api/review')).toBe(false);
+      expect(isConsoleAppRoute('/')).toBe(false);
+    });
+
+    it('does not match a dot-prefixed pjcode', () => {
+      expect(isConsoleAppRoute('/projects/.git')).toBe(false);
+    });
+  });
+
   describe('isTokenValid', () => {
     it('accepts a matching token', () => {
       expect(isTokenValid('expected', 'expected')).toBe(true);
@@ -230,6 +260,57 @@ describe('consoleServer integration', () => {
     }
   });
 
+  it('serves the SPA index for per-project app routes without a token', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const uiDistDir = path.join(tmpDir, 'ui-dist');
+    fs.mkdirSync(uiDistDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(uiDistDir, 'index.html'),
+      '<!DOCTYPE html><title>spa</title><div id="root"></div>',
+    );
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir,
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    try {
+      const projectRoot = await requestServer(server, '/projects/umino');
+      expect(projectRoot.statusCode).toBe(200);
+      expect(projectRoot.body).toContain('spa');
+      expect(projectRoot.contentType).toContain('text/html');
+      expect(projectRoot.cacheControl).toBe('no-store');
+
+      const projectTab = await requestServer(server, '/projects/xmile/prs');
+      expect(projectTab.statusCode).toBe(200);
+      expect(projectTab.body).toContain('spa');
+
+      const unknownTab = await requestServer(server, '/projects/xmile/unknown');
+      expect(unknownTab.statusCode).toBe(404);
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('serves the placeholder index for per-project routes when ui-dist is absent', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
+    const server = await startConsoleServer({
+      accessToken: testToken,
+      uiDistDir: path.join(tmpDir, 'missing-ui-dist'),
+      consoleDataOutputDir: null,
+      port: 0,
+    });
+    try {
+      const projectRoot = await requestServer(server, '/projects/umino/triage');
+      expect(projectRoot.statusCode).toBe(200);
+      expect(projectRoot.body).toContain('TDPM Console');
+    } finally {
+      await closeServer(server);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
   it('rejects dot-prefixed paths with 404', async () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-server-'));
     const uiDistDir = path.join(tmpDir, 'ui-dist');
@@ -399,7 +480,6 @@ describe('consoleServer new routes integration', () => {
       accessToken: testToken,
       uiDistDir: path.join(tmpDir, 'ui-dist'),
       consoleDataOutputDir: dataDir,
-      pjcode: 'umino',
       port: 0,
     });
     try {
@@ -465,9 +545,9 @@ describe('consoleServer new routes integration', () => {
       accessToken: testToken,
       uiDistDir: path.join(tmpDir, 'ui-dist'),
       consoleDataOutputDir: dataDir,
-      pjcode: 'umino',
       issueRepository,
-      project: buildProject(),
+      resolveProject: async (pjcode) =>
+        pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
       port: 0,
     });
     try {
@@ -476,6 +556,7 @@ describe('consoleServer new routes integration', () => {
         'POST',
         `/api/review?k=${testToken}`,
         {
+          pjcode: 'umino',
           action: 'approve',
           prUrl: 'https://github.com/o/r/pull/1',
           projectItemId: 'PVTI_op',
@@ -502,7 +583,8 @@ describe('consoleServer new routes integration', () => {
       uiDistDir: path.join(tmpDir, 'ui-dist'),
       consoleDataOutputDir: null,
       issueRepository,
-      project: buildProject(),
+      resolveProject: async (pjcode) =>
+        pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
       port: 0,
     });
     try {

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

@@ -2,8 +2,8 @@ import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
 import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
-import { Project } from '../../../domain/entities/Project';
 import {
+  CONSOLE_LIST_TAB_NAMES,
   buildConsoleDataResponse,
   parseConsoleDataRoute,
 } from './consoleDataDelivery';
@@ -18,6 +18,7 @@ import {
 } from './consoleReadApi';
 import {
   ConsoleOperationContext,
+  ConsoleProjectResolver,
   handleIntmux,
   handleReview,
   handleTriage,
@@ -70,6 +71,29 @@ export const requiresToken = (requestPath: string): boolean =>
   requestPath === '/api' ||
   requestPath.endsWith('.json');
 
+const SAFE_PJCODE = /^[A-Za-z0-9._-]+$/;
+
+export const isConsoleAppRoute = (requestPath: string): boolean => {
+  const segments = requestPath
+    .split('/')
+    .filter((segment) => segment.length > 0);
+  if (segments.length < 2 || segments[0] !== 'projects') {
+    return false;
+  }
+  const pjcode = segments[1];
+  if (!SAFE_PJCODE.test(pjcode) || pjcode.startsWith('.')) {
+    return false;
+  }
+  if (segments.length === 2) {
+    return true;
+  }
+  if (segments.length !== 3) {
+    return false;
+  }
+  const tab = segments[2];
+  return CONSOLE_LIST_TAB_NAMES.includes(tab);
+};
+
 export const isTokenValid = (
   expectedToken: string,
   providedToken: string | null,
@@ -129,9 +153,8 @@ export type ConsoleServerOptions = {
   accessToken: string;
   uiDistDir: string;
   consoleDataOutputDir: string | null;
-  pjcode?: string | null;
   issueRepository?: IssueRepository | null;
-  project?: Project | null;
+  resolveProject?: ConsoleProjectResolver | null;
   issueTitleStateCache?: IssueTitleStateCache | null;
 };
 
@@ -159,6 +182,24 @@ const serveBootstrapIndex = (response: http.ServerResponse): void => {
   response.end(PLACEHOLDER_INDEX_HTML);
 };
 
+const serveIndexHtml = (
+  options: ConsoleServerOptions,
+  response: http.ServerResponse,
+): void => {
+  const indexFilePath = resolveStaticFilePath(options.uiDistDir, '/index.html');
+  const indexContent =
+    indexFilePath === null ? null : readStaticFile(indexFilePath);
+  if (indexContent === null) {
+    serveBootstrapIndex(response);
+    return;
+  }
+  response.writeHead(200, {
+    'Content-Type': 'text/html; charset=utf-8',
+    'Cache-Control': 'no-store',
+  });
+  response.end(indexContent);
+};
+
 const sendJson = (
   response: http.ServerResponse,
   statusCode: number,
@@ -249,15 +290,14 @@ const handleOperationApi = async (
   body: Record<string, unknown>,
 ): Promise<{ statusCode: number; body: unknown } | null> => {
   const issueRepository = options.issueRepository ?? null;
-  const project = options.project ?? null;
-  if (issueRepository === null || project === null) {
+  const resolveProject = options.resolveProject ?? null;
+  if (issueRepository === null || resolveProject === null) {
     return null;
   }
   const context: ConsoleOperationContext = {
     issueRepository,
-    project,
+    resolveProject,
     consoleDataOutputDir: options.consoleDataOutputDir,
-    pjcode: options.pjcode ?? null,
   };
   switch (requestPath) {
     case '/api/review':
@@ -369,22 +409,12 @@ export const handleConsoleRequest = async (
     return;
   }
 
-  if (requestPath === '/' || requestPath === '/index.html') {
-    const indexFilePath = resolveStaticFilePath(
-      options.uiDistDir,
-      '/index.html',
-    );
-    const indexContent =
-      indexFilePath === null ? null : readStaticFile(indexFilePath);
-    if (indexContent === null) {
-      serveBootstrapIndex(response);
-      return;
-    }
-    response.writeHead(200, {
-      'Content-Type': 'text/html; charset=utf-8',
-      'Cache-Control': 'no-store',
-    });
-    response.end(indexContent);
+  if (
+    requestPath === '/' ||
+    requestPath === '/index.html' ||
+    isConsoleAppRoute(requestPath)
+  ) {
+    serveIndexHtml(options, response);
     return;
   }
 

package/src/adapter/entry-points/console/ui/jest.setup.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/src/adapter/entry-points/console/ui/jest.styleMock.js

@@ -0,0 +1 @@
+module.exports = {};

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

@@ -0,0 +1,34 @@
+import { CONSOLE_COLOR_PALETTE, colorFromEnum } from './colors';
+
+describe('colorFromEnum', () => {
+  it('returns the exact palette entry for a known enum', () => {
+    expect(colorFromEnum('GREEN')).toEqual({
+      dot: '#3fb950',
+      bg: 'rgba(46,160,67,0.15)',
+      fg: '#3fb950',
+      border: 'rgba(46,160,67,0.4)',
+    });
+  });
+
+  it('is case insensitive', () => {
+    expect(colorFromEnum('purple')).toBe(CONSOLE_COLOR_PALETTE.PURPLE);
+  });
+
+  it('falls back to GRAY for an unknown enum', () => {
+    expect(colorFromEnum('MAGENTA')).toBe(CONSOLE_COLOR_PALETTE.GRAY);
+  });
+
+  it('falls back to GRAY for null', () => {
+    expect(colorFromEnum(null)).toBe(CONSOLE_COLOR_PALETTE.GRAY);
+  });
+
+  it('uses the documented dot colors for every enum', () => {
+    expect(CONSOLE_COLOR_PALETTE.GRAY.dot).toBe('#848d97');
+    expect(CONSOLE_COLOR_PALETTE.BLUE.dot).toBe('#4493f8');
+    expect(CONSOLE_COLOR_PALETTE.YELLOW.dot).toBe('#d29922');
+    expect(CONSOLE_COLOR_PALETTE.ORANGE.dot).toBe('#db6d28');
+    expect(CONSOLE_COLOR_PALETTE.RED.dot).toBe('#f85149');
+    expect(CONSOLE_COLOR_PALETTE.PINK.dot).toBe('#db61a2');
+    expect(CONSOLE_COLOR_PALETTE.PURPLE.dot).toBe('#a371f7');
+  });
+});

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

@@ -0,0 +1,73 @@
+import type { ConsoleColor } from './types';
+
+export type ConsolePaletteEntry = {
+  dot: string;
+  bg: string;
+  fg: string;
+  border: string;
+};
+
+export const CONSOLE_COLOR_PALETTE: Record<ConsoleColor, ConsolePaletteEntry> =
+  {
+    GRAY: {
+      dot: '#848d97',
+      bg: 'rgba(110,118,129,0.1)',
+      fg: '#8b949e',
+      border: 'rgba(110,118,129,0.4)',
+    },
+    BLUE: {
+      dot: '#4493f8',
+      bg: 'rgba(56,139,253,0.1)',
+      fg: '#388bfd',
+      border: 'rgba(56,139,253,0.4)',
+    },
+    GREEN: {
+      dot: '#3fb950',
+      bg: 'rgba(46,160,67,0.15)',
+      fg: '#3fb950',
+      border: 'rgba(46,160,67,0.4)',
+    },
+    YELLOW: {
+      dot: '#d29922',
+      bg: 'rgba(187,128,9,0.15)',
+      fg: '#d29922',
+      border: 'rgba(187,128,9,0.4)',
+    },
+    ORANGE: {
+      dot: '#db6d28',
+      bg: 'rgba(219,109,40,0.1)',
+      fg: '#db6d28',
+      border: 'rgba(219,109,40,0.4)',
+    },
+    RED: {
+      dot: '#f85149',
+      bg: 'rgba(248,81,73,0.1)',
+      fg: '#f85149',
+      border: 'rgba(248,81,73,0.4)',
+    },
+    PINK: {
+      dot: '#db61a2',
+      bg: 'rgba(219,97,162,0.1)',
+      fg: '#db61a2',
+      border: 'rgba(219,97,162,0.4)',
+    },
+    PURPLE: {
+      dot: '#a371f7',
+      bg: 'rgba(163,113,247,0.1)',
+      fg: '#a371f7',
+      border: 'rgba(163,113,247,0.4)',
+    },
+  };
+
+export const colorFromEnum = (
+  colorEnum: string | null,
+): ConsolePaletteEntry => {
+  if (colorEnum === null) {
+    return CONSOLE_COLOR_PALETTE.GRAY;
+  }
+  const key = colorEnum.toUpperCase();
+  if (key in CONSOLE_COLOR_PALETTE) {
+    return CONSOLE_COLOR_PALETTE[key as ConsoleColor];
+  }
+  return CONSOLE_COLOR_PALETTE.GRAY;
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/ConsoleChangedFileList.stories.tsx

@@ -0,0 +1,28 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { consoleChangedFilesFixture } from '../fixtures';
+import { ConsoleChangedFileList } from './ConsoleChangedFileList';
+
+const meta: Meta<typeof ConsoleChangedFileList> = {
+  title: 'Console/ConsoleChangedFileList',
+  component: ConsoleChangedFileList,
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleChangedFileList>;
+
+export const WithFiles: Story = {
+  args: { files: consoleChangedFilesFixture, isLoading: false, error: null },
+};
+
+export const Loading: Story = {
+  args: { files: [], isLoading: true, error: null },
+};
+
+export const Empty: Story = {
+  args: { files: [], isLoading: false, error: null },
+};
+
+export const ErrorState: Story = {
+  args: { files: [], isLoading: false, error: 'HTTP 502' },
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/ConsoleChangedFileList.test.tsx

@@ -0,0 +1,42 @@
+import { render } from '@testing-library/react';
+import { consoleChangedFilesFixture } from '../fixtures';
+import { ConsoleChangedFileList } from './ConsoleChangedFileList';
+
+describe('ConsoleChangedFileList', () => {
+  it('renders each file path, status badge and additions/deletions', () => {
+    const { getByText, getAllByText } = render(
+      <ConsoleChangedFileList
+        files={consoleChangedFilesFixture}
+        isLoading={false}
+        error={null}
+      />,
+    );
+    expect(
+      getByText('src/adapter/entry-points/console/consoleServer.ts'),
+    ).toBeInTheDocument();
+    expect(getByText('+312')).toBeInTheDocument();
+    expect(getAllByText('A').length).toBe(2);
+    expect(getByText('M')).toBeInTheDocument();
+  });
+
+  it('shows the loading state', () => {
+    const { getByText } = render(
+      <ConsoleChangedFileList files={[]} isLoading error={null} />,
+    );
+    expect(getByText('Loading changed files...')).toBeInTheDocument();
+  });
+
+  it('shows the empty state', () => {
+    const { getByText } = render(
+      <ConsoleChangedFileList files={[]} isLoading={false} error={null} />,
+    );
+    expect(getByText('No changed files.')).toBeInTheDocument();
+  });
+
+  it('shows the error state', () => {
+    const { getByRole } = render(
+      <ConsoleChangedFileList files={[]} isLoading={false} error="HTTP 502" />,
+    );
+    expect(getByRole('alert')).toHaveTextContent('HTTP 502');
+  });
+});

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

@@ -0,0 +1,55 @@
+import { fileStatusBadge } from '../fileStatus';
+import type { ConsoleChangedFile } from '../types';
+
+export type ConsoleChangedFileListProps = {
+  files: ConsoleChangedFile[];
+  isLoading: boolean;
+  error: string | null;
+};
+
+export const ConsoleChangedFileList = ({
+  files,
+  isLoading,
+  error,
+}: ConsoleChangedFileListProps) => {
+  if (error !== null) {
+    return (
+      <p role="alert" className="console-files-error">
+        Failed to load changed files: {error}
+      </p>
+    );
+  }
+
+  if (isLoading) {
+    return <p className="console-files-loading">Loading changed files...</p>;
+  }
+
+  if (files.length === 0) {
+    return <p className="console-files-empty">No changed files.</p>;
+  }
+
+  return (
+    <ul className="console-files">
+      {files.map((file) => {
+        const badge = fileStatusBadge(file.status);
+        return (
+          <li key={file.path} className="console-file">
+            <span
+              className="console-file-badge"
+              style={{ color: badge.color, borderColor: badge.color }}
+            >
+              {badge.label}
+            </span>
+            <span className="console-file-path">{file.path}</span>
+            <span className="console-file-stat console-file-add">
+              +{file.additions}
+            </span>
+            <span className="console-file-stat console-file-del">
+              -{file.deletions}
+            </span>
+          </li>
+        );
+      })}
+    </ul>
+  );
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/ConsoleCloseButtonGroup.stories.tsx

@@ -0,0 +1,14 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { ConsoleCloseButtonGroup } from './ConsoleCloseButtonGroup';
+
+const meta: Meta<typeof ConsoleCloseButtonGroup> = {
+  title: 'Console/ConsoleCloseButtonGroup',
+  component: ConsoleCloseButtonGroup,
+  args: { onClose: () => {} },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleCloseButtonGroup>;
+
+export const Default: Story = {};