claude-code-swarm 0.0.1 → 0.3.3

package/references/openhive/src/utils/git-remote.ts

@@ -0,0 +1,329 @@
+/**
+ * Git Remote Utilities
+ *
+ * Provides functions for checking remote git repository state without webhooks.
+ * Supports GitHub, GitLab, and generic git remotes via git ls-remote.
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export interface RemoteRefInfo {
+  commitHash: string;
+  ref: string;
+  timestamp?: string; // Only available from API calls, not git ls-remote
+}
+
+export interface CheckRemoteResult {
+  success: boolean;
+  ref?: RemoteRefInfo;
+  error?: string;
+  source: 'github-api' | 'gitlab-api' | 'git-ls-remote' | 'unknown';
+}
+
+/**
+ * Parse a git remote URL into host, owner, and repo components.
+ */
+export function parseGitUrl(url: string): {
+  host: string;
+  owner: string;
+  repo: string;
+} | null {
+  // Normalize the URL
+  let normalized = url.trim();
+
+  // Handle SSH format: git@github.com:user/repo.git
+  const sshMatch = normalized.match(/^git@([^:]+):([^/]+)\/(.+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { host: sshMatch[1], owner: sshMatch[2], repo: sshMatch[3] };
+  }
+
+  // Handle HTTPS format: https://github.com/user/repo.git
+  const httpsMatch = normalized.match(
+    /^https?:\/\/([^/]+)\/([^/]+)\/(.+?)(?:\.git)?$/
+  );
+  if (httpsMatch) {
+    return { host: httpsMatch[1], owner: httpsMatch[2], repo: httpsMatch[3] };
+  }
+
+  // Handle git:// format: git://github.com/user/repo.git
+  const gitMatch = normalized.match(
+    /^git:\/\/([^/]+)\/([^/]+)\/(.+?)(?:\.git)?$/
+  );
+  if (gitMatch) {
+    return { host: gitMatch[1], owner: gitMatch[2], repo: gitMatch[3] };
+  }
+
+  // Handle simple format: github.com/user/repo
+  const simpleMatch = normalized.match(/^([^/]+)\/([^/]+)\/(.+?)(?:\.git)?$/);
+  if (simpleMatch) {
+    return { host: simpleMatch[1], owner: simpleMatch[2], repo: simpleMatch[3] };
+  }
+
+  return null;
+}
+
+/**
+ * Check GitHub repo for latest commit on default branch using API.
+ * Works for public repos without authentication.
+ */
+async function checkGitHubApi(
+  owner: string,
+  repo: string,
+  branch: string = 'main'
+): Promise<CheckRemoteResult> {
+  const branches = branch === 'main' ? ['main', 'master'] : [branch];
+
+  for (const branchName of branches) {
+    try {
+      const response = await fetch(
+        `https://api.github.com/repos/${owner}/${repo}/commits/${branchName}`,
+        {
+          headers: {
+            Accept: 'application/vnd.github.v3+json',
+            'User-Agent': 'OpenHive-MemoryBank-Sync',
+          },
+        }
+      );
+
+      if (response.status === 404 && branchName === 'main') {
+        // Try master branch
+        continue;
+      }
+
+      if (!response.ok) {
+        if (response.status === 403) {
+          return {
+            success: false,
+            error: 'GitHub API rate limit exceeded',
+            source: 'github-api',
+          };
+        }
+        return {
+          success: false,
+          error: `GitHub API error: ${response.status}`,
+          source: 'github-api',
+        };
+      }
+
+      const data = (await response.json()) as {
+        sha: string;
+        commit: { committer: { date: string } };
+      };
+
+      return {
+        success: true,
+        ref: {
+          commitHash: data.sha,
+          ref: `refs/heads/${branchName}`,
+          timestamp: data.commit?.committer?.date,
+        },
+        source: 'github-api',
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `GitHub API error: ${(error as Error).message}`,
+        source: 'github-api',
+      };
+    }
+  }
+
+  return {
+    success: false,
+    error: 'Branch not found',
+    source: 'github-api',
+  };
+}
+
+/**
+ * Check GitLab repo for latest commit using API.
+ * Works for public repos without authentication.
+ */
+async function checkGitLabApi(
+  host: string,
+  owner: string,
+  repo: string,
+  branch: string = 'main'
+): Promise<CheckRemoteResult> {
+  const projectPath = encodeURIComponent(`${owner}/${repo}`);
+  const branches = branch === 'main' ? ['main', 'master'] : [branch];
+
+  for (const branchName of branches) {
+    try {
+      const response = await fetch(
+        `https://${host}/api/v4/projects/${projectPath}/repository/branches/${branchName}`,
+        {
+          headers: {
+            'User-Agent': 'OpenHive-MemoryBank-Sync',
+          },
+        }
+      );
+
+      if (response.status === 404 && branchName === 'main') {
+        // Try master branch
+        continue;
+      }
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `GitLab API error: ${response.status}`,
+          source: 'gitlab-api',
+        };
+      }
+
+      const data = (await response.json()) as {
+        commit: { id: string; committed_date: string };
+      };
+
+      return {
+        success: true,
+        ref: {
+          commitHash: data.commit.id,
+          ref: `refs/heads/${branchName}`,
+          timestamp: data.commit.committed_date,
+        },
+        source: 'gitlab-api',
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `GitLab API error: ${(error as Error).message}`,
+        source: 'gitlab-api',
+      };
+    }
+  }
+
+  return {
+    success: false,
+    error: 'Branch not found',
+    source: 'gitlab-api',
+  };
+}
+
+/**
+ * Check remote using git ls-remote command.
+ * Works with any git remote but requires git to be installed.
+ */
+async function checkGitLsRemote(
+  url: string,
+  branch: string = 'main'
+): Promise<CheckRemoteResult> {
+  const branches = branch === 'main' ? ['main', 'master'] : [branch];
+
+  for (const branchName of branches) {
+    try {
+      const { stdout } = await execAsync(
+        `git ls-remote --refs ${url} refs/heads/${branchName}`,
+        { timeout: 15000 }
+      );
+
+      const lines = stdout.trim().split('\n');
+      if (lines.length > 0 && lines[0]) {
+        const [hash, ref] = lines[0].split('\t');
+        if (hash && ref) {
+          return {
+            success: true,
+            ref: {
+              commitHash: hash,
+              ref: ref,
+            },
+            source: 'git-ls-remote',
+          };
+        }
+      }
+
+      // If main not found, try master
+      if (branchName === 'main') {
+        continue;
+      }
+    } catch (error) {
+      // If main fails, try master before giving up
+      if (branchName === 'main') {
+        continue;
+      }
+      return {
+        success: false,
+        error: `git ls-remote failed: ${(error as Error).message}`,
+        source: 'git-ls-remote',
+      };
+    }
+  }
+
+  return {
+    success: false,
+    error: 'Could not find branch',
+    source: 'git-ls-remote',
+  };
+}
+
+/**
+ * Check a git remote for the latest commit on the default branch.
+ * Automatically selects the best method based on the host.
+ *
+ * @param gitRemoteUrl - The git remote URL to check
+ * @param branch - The branch to check (defaults to 'main', will also try 'master')
+ */
+export async function checkRemoteForUpdates(
+  gitRemoteUrl: string,
+  branch: string = 'main'
+): Promise<CheckRemoteResult> {
+  const parsed = parseGitUrl(gitRemoteUrl);
+
+  if (!parsed) {
+    // Can't parse URL, try git ls-remote as fallback
+    return checkGitLsRemote(gitRemoteUrl, branch);
+  }
+
+  const { host, owner, repo } = parsed;
+
+  // Try API first for known hosts (faster, no git dependency)
+  if (host === 'github.com') {
+    const result = await checkGitHubApi(owner, repo, branch);
+    if (result.success) {
+      return result;
+    }
+    // Fall back to git ls-remote if API fails (e.g., rate limited)
+  }
+
+  if (host === 'gitlab.com' || host.includes('gitlab')) {
+    const result = await checkGitLabApi(host, owner, repo, branch);
+    if (result.success) {
+      return result;
+    }
+    // Fall back to git ls-remote
+  }
+
+  // For other hosts or as fallback, use git ls-remote
+  return checkGitLsRemote(gitRemoteUrl, branch);
+}
+
+/**
+ * Check multiple remotes in parallel with concurrency limit.
+ */
+export async function checkRemotesBatch(
+  remotes: Array<{ id: string; gitRemoteUrl: string; branch?: string }>,
+  concurrency: number = 5
+): Promise<Map<string, CheckRemoteResult>> {
+  const results = new Map<string, CheckRemoteResult>();
+
+  // Process in batches to limit concurrency
+  for (let i = 0; i < remotes.length; i += concurrency) {
+    const batch = remotes.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map(async ({ id, gitRemoteUrl, branch }) => {
+        const result = await checkRemoteForUpdates(gitRemoteUrl, branch);
+        return { id, result };
+      })
+    );
+
+    for (const { id, result } of batchResults) {
+      results.set(id, result);
+    }
+  }
+
+  return results;
+}

package/references/openhive/src/web/App.tsx

@@ -0,0 +1,77 @@
+import { lazy, Suspense, useEffect } from 'react';
+import { Routes, Route } from 'react-router-dom';
+import { Layout } from './components/layout/Layout';
+import { PageLoader } from './components/common/LoadingSpinner';
+import { ErrorBoundary } from './components/common/ErrorBoundary';
+import { ProtectedRoute } from './components/common/ProtectedRoute';
+import { useWebSocket } from './hooks/useWebSocket';
+import { useAuthStore } from './stores/auth';
+
+// Lazy load page components for code splitting
+const Dashboard = lazy(() => import('./pages/Dashboard').then(m => ({ default: m.Dashboard })));
+const Explore = lazy(() => import('./pages/Explore').then(m => ({ default: m.Explore })));
+const Hive = lazy(() => import('./pages/Hive').then(m => ({ default: m.Hive })));
+const Post = lazy(() => import('./pages/Post').then(m => ({ default: m.Post })));
+const Agent = lazy(() => import('./pages/Agent').then(m => ({ default: m.Agent })));
+const Hives = lazy(() => import('./pages/Hives').then(m => ({ default: m.Hives })));
+const Agents = lazy(() => import('./pages/Agents').then(m => ({ default: m.Agents })));
+const Search = lazy(() => import('./pages/Search').then(m => ({ default: m.Search })));
+const About = lazy(() => import('./pages/About').then(m => ({ default: m.About })));
+const Login = lazy(() => import('./pages/Login').then(m => ({ default: m.Login })));
+const AuthCallback = lazy(() => import('./pages/AuthCallback').then(m => ({ default: m.AuthCallback })));
+const Settings = lazy(() => import('./pages/Settings').then(m => ({ default: m.Settings })));
+const Swarms = lazy(() => import('./pages/Swarms').then(m => ({ default: m.Swarms })));
+const SwarmCraft = lazy(() => import('./pages/SwarmCraft').then(m => ({ default: m.SwarmCraft })));
+const Terminal = lazy(() => import('./pages/Terminal').then(m => ({ default: m.Terminal })));
+const Resources = lazy(() => import('./pages/Resources').then(m => ({ default: m.Resources })));
+const ResourceDetail = lazy(() => import('./pages/ResourceDetail').then(m => ({ default: m.ResourceDetail })));
+const Sessions = lazy(() => import('./pages/Sessions').then(m => ({ default: m.Sessions })));
+const SessionDetail = lazy(() => import('./pages/SessionDetail').then(m => ({ default: m.SessionDetail })));
+const Events = lazy(() => import('./pages/Events').then(m => ({ default: m.Events })));
+
+export default function App() {
+  // Initialize WebSocket connection
+  useWebSocket();
+
+  // Check auth mode on startup (local mode auto-authenticates)
+  const checkAuthMode = useAuthStore((s) => s.checkAuthMode);
+  useEffect(() => {
+    checkAuthMode();
+  }, [checkAuthMode]);
+
+  return (
+    <ErrorBoundary>
+      <Suspense fallback={<PageLoader />}>
+        <Routes>
+          <Route path="/" element={<Layout />}>
+            {/* Public routes */}
+            <Route path="login" element={<Login />} />
+            <Route path="auth/callback" element={<AuthCallback />} />
+
+            {/* Protected routes */}
+            <Route element={<ProtectedRoute />}>
+              <Route index element={<Dashboard />} />
+              <Route path="explore" element={<Explore />} />
+              <Route path="h/:hiveName" element={<Hive />} />
+              <Route path="h/:hiveName/post/:postId" element={<Post />} />
+              <Route path="a/:agentName" element={<Agent />} />
+              <Route path="hives" element={<Hives />} />
+              <Route path="agents" element={<Agents />} />
+              <Route path="search" element={<Search />} />
+              <Route path="about" element={<About />} />
+              <Route path="settings" element={<Settings />} />
+              <Route path="swarms" element={<Swarms />} />
+              <Route path="sessions" element={<Sessions />} />
+              <Route path="sessions/:id" element={<SessionDetail />} />
+              <Route path="events" element={<Events />} />
+              <Route path="resources" element={<Resources />} />
+              <Route path="resources/:id" element={<ResourceDetail />} />
+              <Route path="swarmcraft" element={<SwarmCraft />} />
+              <Route path="terminal/:swarmId" element={<Terminal />} />
+            </Route>
+          </Route>
+        </Routes>
+      </Suspense>
+    </ErrorBoundary>
+  );
+}

package/references/openhive/src/web/__tests__/components/dashboard/RecentActivity.test.tsx

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { RecentActivity } from '../../../components/dashboard/RecentActivity';
+import { useDashboardStore } from '../../../stores/dashboard';
+
+// Mock WebSocket hooks
+vi.mock('../../../hooks/useWebSocket', () => ({
+  useSubscribe: vi.fn(),
+  useWSEvent: vi.fn(),
+}));
+
+describe('RecentActivity', () => {
+  beforeEach(() => {
+    // Reset the Zustand store between tests
+    useDashboardStore.setState({ activities: [] });
+  });
+
+  it('shows empty state message when no activity', () => {
+    render(<RecentActivity />);
+    expect(screen.getByText('No recent activity. Events will appear here in real-time.')).toBeDefined();
+  });
+
+  it('renders activity items from the store', () => {
+    useDashboardStore.setState({
+      activities: [
+        { id: '1', type: 'swarm_registered', message: 'Swarm "alpha" registered', timestamp: new Date().toISOString() },
+        { id: '2', type: 'memory:sync', message: 'Memory synced (res_mem_1)', timestamp: new Date().toISOString() },
+      ],
+    });
+
+    render(<RecentActivity />);
+    expect(screen.getByText('Swarm "alpha" registered')).toBeDefined();
+    expect(screen.getByText('Memory synced (res_mem_1)')).toBeDefined();
+  });
+
+  it('limits displayed items to 20', () => {
+    const activities = Array.from({ length: 30 }, (_, i) => ({
+      id: String(i),
+      type: 'swarm_registered',
+      message: `Event ${i}`,
+      timestamp: new Date().toISOString(),
+    }));
+    useDashboardStore.setState({ activities });
+
+    render(<RecentActivity />);
+    // Should show first 20 (items 0-19), not the full 30
+    expect(screen.getByText('Event 0')).toBeDefined();
+    expect(screen.getByText('Event 19')).toBeDefined();
+    expect(screen.queryByText('Event 20')).toBeNull();
+  });
+
+  it('subscribes to global and map:discovery channels', async () => {
+    const { useSubscribe } = await import('../../../hooks/useWebSocket');
+    render(<RecentActivity />);
+    expect(useSubscribe).toHaveBeenCalledWith(['global', 'map:discovery']);
+  });
+
+  it('registers WebSocket event listeners for all expected event types', async () => {
+    const { useWSEvent } = await import('../../../hooks/useWebSocket');
+    render(<RecentActivity />);
+
+    const registeredEvents = (useWSEvent as ReturnType<typeof vi.fn>).mock.calls.map(
+      (call: unknown[]) => call[0]
+    );
+
+    expect(registeredEvents).toContain('swarm_registered');
+    expect(registeredEvents).toContain('swarm_offline');
+    expect(registeredEvents).toContain('node_registered');
+    expect(registeredEvents).toContain('node_state_changed');
+    expect(registeredEvents).toContain('swarm_spawned');
+    expect(registeredEvents).toContain('swarm_stopped');
+    expect(registeredEvents).toContain('memory:sync');
+    expect(registeredEvents).toContain('skill:sync');
+    expect(registeredEvents).toContain('resource_updated');
+    expect(registeredEvents).toContain('resource_created');
+  });
+});

package/references/openhive/src/web/__tests__/components/dashboard/StatsOverview.test.tsx

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { StatsOverview } from '../../../components/dashboard/StatsOverview';
+
+const mockMapStats = {
+  swarms: { total: 12, online: 8, offline: 4 },
+  nodes: { total: 34, active: 28 },
+  hive_memberships: 5,
+  preauth_keys: { total: 3, active: 2 },
+};
+
+vi.mock('../../../hooks/useApi', () => ({
+  useMapStats: vi.fn().mockReturnValue({
+    data: {
+      swarms: { total: 12, online: 8, offline: 4 },
+      nodes: { total: 34, active: 28 },
+      hive_memberships: 5,
+      preauth_keys: { total: 3, active: 2 },
+    },
+    isLoading: false,
+  }),
+}));
+
+function renderWithQuery(ui: React.ReactElement) {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return render(
+    <QueryClientProvider client={queryClient}>{ui}</QueryClientProvider>
+  );
+}
+
+describe('StatsOverview', () => {
+  it('renders four stat cards', () => {
+    renderWithQuery(<StatsOverview />);
+    expect(screen.getByText('Total Swarms')).toBeDefined();
+    expect(screen.getByText('Online')).toBeDefined();
+    expect(screen.getByText('Agents')).toBeDefined();
+    expect(screen.getByText('Hive Links')).toBeDefined();
+  });
+
+  it('displays correct stat values', () => {
+    renderWithQuery(<StatsOverview />);
+    expect(screen.getByText('12')).toBeDefined(); // total swarms
+    expect(screen.getByText('8')).toBeDefined();  // online
+    expect(screen.getByText('34')).toBeDefined(); // agents
+    expect(screen.getByText('5')).toBeDefined();  // hive links
+  });
+
+  it('shows loading skeleton when data is loading', async () => {
+    const { useMapStats } = await import('../../../hooks/useApi');
+    (useMapStats as ReturnType<typeof vi.fn>).mockReturnValue({
+      data: undefined,
+      isLoading: true,
+    });
+
+    const { container } = renderWithQuery(<StatsOverview />);
+    const skeletons = container.querySelectorAll('.animate-pulse');
+    expect(skeletons.length).toBe(4);
+  });
+});

package/references/openhive/src/web/__tests__/components/dashboard/SwarmStatusSummary.test.tsx

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { SwarmStatusSummary } from '../../../components/dashboard/SwarmStatusSummary';
+
+const mockUseHostedSwarms = vi.fn();
+const mockUseMapSwarms = vi.fn();
+
+vi.mock('../../../hooks/useApi', () => ({
+  useHostedSwarms: (...args: unknown[]) => mockUseHostedSwarms(...args),
+  useMapSwarms: (...args: unknown[]) => mockUseMapSwarms(...args),
+}));
+
+function renderWithProviders(ui: React.ReactElement) {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return render(
+    <QueryClientProvider client={queryClient}>
+      <MemoryRouter>{ui}</MemoryRouter>
+    </QueryClientProvider>
+  );
+}
+
+describe('SwarmStatusSummary', () => {
+  it('shows empty state when no swarms exist', () => {
+    mockUseHostedSwarms.mockReturnValue({ data: [] });
+    mockUseMapSwarms.mockReturnValue({ data: [] });
+
+    renderWithProviders(<SwarmStatusSummary />);
+    expect(screen.getByText('No swarms connected')).toBeDefined();
+    expect(screen.getByText('Connect a swarm')).toBeDefined();
+  });
+
+  it('renders hosted swarms with state badges', () => {
+    mockUseHostedSwarms.mockReturnValue({
+      data: [
+        { id: 'swarm-alpha', name: 'swarm-alpha', state: 'running', provider: 'local', created_at: '2025-01-01T00:00:00Z' },
+        { id: 'swarm-beta', name: 'swarm-beta', state: 'stopped', provider: 'docker', created_at: '2025-01-01T00:00:00Z' },
+      ],
+    });
+    mockUseMapSwarms.mockReturnValue({ data: [] });
+
+    renderWithProviders(<SwarmStatusSummary />);
+    expect(screen.getByText('swarm-alpha')).toBeDefined();
+    expect(screen.getByText('swarm-beta')).toBeDefined();
+    expect(screen.getByText('Running')).toBeDefined();
+    expect(screen.getByText('Stopped')).toBeDefined();
+  });
+
+  it('renders map swarms with status badges', () => {
+    mockUseHostedSwarms.mockReturnValue({ data: [] });
+    mockUseMapSwarms.mockReturnValue({
+      data: [
+        {
+          id: 'ext-1', name: 'external-swarm', status: 'online', agent_count: 5,
+          map_endpoint: 'ws://localhost:3000', created_at: '2025-01-01T00:00:00Z',
+        },
+      ],
+    });
+
+    renderWithProviders(<SwarmStatusSummary />);
+    expect(screen.getByText('external-swarm')).toBeDefined();
+    expect(screen.getByText('Online')).toBeDefined();
+    expect(screen.getByText('registered')).toBeDefined();
+  });
+
+  it('shows combined total count', () => {
+    mockUseHostedSwarms.mockReturnValue({
+      data: [{ id: 'h1', state: 'running', created_at: '2025-01-01T00:00:00Z' }],
+    });
+    mockUseMapSwarms.mockReturnValue({
+      data: [
+        { id: 'm1', name: 'map1', status: 'online', agent_count: 2, created_at: '2025-01-01T00:00:00Z' },
+      ],
+    });
+
+    renderWithProviders(<SwarmStatusSummary />);
+    expect(screen.getByText('2 total')).toBeDefined();
+  });
+
+  it('sorts swarms by status priority (running/online first)', () => {
+    mockUseHostedSwarms.mockReturnValue({
+      data: [
+        { id: 'stopped-swarm', name: 'stopped-swarm', state: 'stopped', created_at: '2025-01-01T00:00:00Z' },
+        { id: 'running-swarm', name: 'running-swarm', state: 'running', created_at: '2025-01-01T00:00:00Z' },
+      ],
+    });
+    mockUseMapSwarms.mockReturnValue({ data: [] });
+
+    renderWithProviders(<SwarmStatusSummary />);
+    const names = screen.getAllByText(/swarm/).map((el) => el.textContent);
+    // running-swarm should appear before stopped-swarm
+    const runningIdx = names.indexOf('running-swarm');
+    const stoppedIdx = names.indexOf('stopped-swarm');
+    expect(runningIdx).toBeLessThan(stoppedIdx);
+  });
+
+  it('limits display to 8 swarms', () => {
+    const hosted = Array.from({ length: 10 }, (_, i) => ({
+      id: `swarm-${i}`, state: 'running' as const, created_at: '2025-01-01T00:00:00Z',
+    }));
+    mockUseHostedSwarms.mockReturnValue({ data: hosted });
+    mockUseMapSwarms.mockReturnValue({ data: [] });
+
+    renderWithProviders(<SwarmStatusSummary />);
+    const hostedLabels = screen.getAllByText('hosted');
+    expect(hostedLabels.length).toBe(8);
+  });
+
+  it('contains a "View all swarms" link to /swarms', () => {
+    mockUseHostedSwarms.mockReturnValue({
+      data: [{ id: 's1', state: 'running', created_at: '2025-01-01T00:00:00Z' }],
+    });
+    mockUseMapSwarms.mockReturnValue({ data: [] });
+
+    renderWithProviders(<SwarmStatusSummary />);
+    const link = screen.getByText('View all swarms');
+    expect(link.closest('a')!.getAttribute('href')).toBe('/swarms');
+  });
+});