@a5c-ai/babysitter-observer-dashboard 5.0.1-staging.7a8768ec

package/src/lib/__tests__/source-discovery.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import path from 'path';
+import { promises as fs } from 'fs';
+
+// Mock config-loader since source-discovery imports getConfig from it
+vi.mock('../config-loader', () => ({
+  isNotFoundError: vi.fn((err: unknown) => {
+    if (!(err instanceof Error)) return false;
+    const code = (err as NodeJS.ErrnoException).code;
+    return code === 'ENOENT' || code === 'ENOTDIR' || err.message.includes('ENOENT');
+  }),
+  getConfig: vi.fn(),
+}));
+
+import { getConfig } from '../config-loader';
+import {
+  invalidateDiscoveryCache,
+  discoverAllRunDirs,
+  discoverAllRunsParentDirs,
+} from '../source-discovery';
+
+const mockGetConfig = vi.mocked(getConfig);
+const mockReadFile = vi.spyOn(fs, 'readFile');
+const mockReaddir = vi.spyOn(fs, 'readdir');
+const mockStat = vi.spyOn(fs, 'stat');
+const mockAccess = vi.spyOn(fs, 'access');
+
+describe('source-discovery', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    invalidateDiscoveryCache();
+    mockAccess.mockRejectedValue(new Error('ENOENT'));
+  });
+
+  describe('invalidateDiscoveryCache', () => {
+    it('forces re-discovery on next call', async () => {
+      mockGetConfig.mockResolvedValue({
+        sources: [{ path: '/projects/my-app', depth: 2 }],
+        port: 4800,
+        pollInterval: 2000,
+        theme: 'dark',
+        staleThresholdMs: 3600000,
+        recentCompletionWindowMs: 14400000,
+        retentionDays: 30,
+        hiddenProjects: [],
+      });
+
+      // Return a non-empty result so the discovery cache is populated
+      mockStat.mockImplementation(async (p: unknown) => {
+        if (String(p) === path.join('/projects/my-app', '.a5c', 'runs')) {
+          return { isDirectory: () => true } as unknown as fs.FileHandle;
+        }
+        throw new Error('ENOENT');
+      });
+      mockReaddir.mockImplementation(async (dir: unknown) => {
+        const dirStr = typeof dir === 'string' ? dir : String(dir);
+        if (dirStr === '/projects/my-app') {
+          return [] as unknown as ReturnType<typeof fs.readdir>;
+        }
+        if (dirStr === path.join('/projects/my-app', '.a5c', 'runs')) {
+          return [
+            { name: 'run-001', isDirectory: () => true },
+          ] as unknown as ReturnType<typeof fs.readdir>;
+        }
+        return [] as unknown as ReturnType<typeof fs.readdir>;
+      });
+
+      await discoverAllRunDirs();
+      await discoverAllRunDirs();
+
+      // With caching (non-empty results), getConfig should only be called once
+      expect(mockGetConfig).toHaveBeenCalledTimes(1);
+
+      invalidateDiscoveryCache();
+      await discoverAllRunDirs();
+
+      // After invalidation, getConfig should be called again
+      expect(mockGetConfig).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('discoverAllRunDirs', () => {
+    it('returns empty array when source directory does not exist', async () => {
+      mockGetConfig.mockResolvedValue({
+        sources: [{ path: '/nonexistent', depth: 2 }],
+        port: 4800,
+        pollInterval: 2000,
+        theme: 'dark',
+        staleThresholdMs: 3600000,
+        recentCompletionWindowMs: 14400000,
+        retentionDays: 30,
+        hiddenProjects: [],
+      });
+
+      mockStat.mockRejectedValue(new Error('ENOENT'));
+      mockReaddir.mockRejectedValue(new Error('ENOENT'));
+
+      const results = await discoverAllRunDirs();
+      expect(results).toEqual([]);
+    });
+
+    it('discovers run directories within .a5c/runs at source root', async () => {
+      mockGetConfig.mockResolvedValue({
+        sources: [{ path: '/projects/my-project', depth: 2 }],
+        port: 4800,
+        pollInterval: 2000,
+        theme: 'dark',
+        staleThresholdMs: 3600000,
+        recentCompletionWindowMs: 14400000,
+        retentionDays: 30,
+        hiddenProjects: [],
+      });
+
+      mockStat.mockImplementation(async (p: unknown) => {
+        if (p === path.join('/projects/my-project', '.a5c', 'runs')) {
+          return { isDirectory: () => true } as unknown as fs.FileHandle;
+        }
+        throw new Error('ENOENT');
+      });
+
+      mockReaddir.mockImplementation(async (dir: unknown) => {
+        const dirStr = typeof dir === 'string' ? dir : String(dir);
+        if (dirStr === '/projects/my-project') {
+          return [] as unknown as ReturnType<typeof fs.readdir>;
+        }
+        if (dirStr === path.join('/projects/my-project', '.a5c', 'runs')) {
+          return [
+            { name: 'run-001', isDirectory: () => true },
+            { name: 'run-002', isDirectory: () => true },
+          ] as unknown as ReturnType<typeof fs.readdir>;
+        }
+        return [] as unknown as ReturnType<typeof fs.readdir>;
+      });
+
+      const results = await discoverAllRunDirs();
+
+      expect(results).toHaveLength(2);
+      expect(results[0].runDir).toBe(
+        path.join('/projects/my-project', '.a5c', 'runs', 'run-001'),
+      );
+      expect(results[0].projectName).toBe('my-project');
+    });
+
+    it('handles depth=0 sources (direct runs directory)', async () => {
+      mockGetConfig.mockResolvedValue({
+        sources: [{ path: '/direct/runs', depth: 0, label: 'direct' }],
+        port: 4800,
+        pollInterval: 2000,
+        theme: 'dark',
+        staleThresholdMs: 3600000,
+        recentCompletionWindowMs: 14400000,
+        retentionDays: 30,
+        hiddenProjects: [],
+      });
+
+      mockReadFile.mockRejectedValue(new Error('ENOENT'));
+
+      mockReaddir.mockImplementation(async (dir: unknown) => {
+        const dirStr = typeof dir === 'string' ? dir : String(dir);
+        if (dirStr === '/direct/runs') {
+          return [
+            { name: 'run-a', isDirectory: () => true },
+            { name: 'somefile.txt', isDirectory: () => false },
+          ] as unknown as ReturnType<typeof fs.readdir>;
+        }
+        return [] as unknown as ReturnType<typeof fs.readdir>;
+      });
+
+      const results = await discoverAllRunDirs();
+
+      expect(results).toHaveLength(1);
+      expect(results[0].runDir).toBe(path.join('/direct/runs', 'run-a'));
+      expect(results[0].projectName).toBe('direct');
+    });
+
+    it('skips node_modules and hidden directories during scanning', async () => {
+      mockGetConfig.mockResolvedValue({
+        sources: [{ path: '/workspace', depth: 1 }],
+        port: 4800,
+        pollInterval: 2000,
+        theme: 'dark',
+        staleThresholdMs: 3600000,
+        recentCompletionWindowMs: 14400000,
+        retentionDays: 30,
+        hiddenProjects: [],
+      });
+
+      mockStat.mockRejectedValue(new Error('ENOENT'));
+
+      mockReaddir.mockImplementation(async (dir: unknown) => {
+        const dirStr = typeof dir === 'string' ? dir : String(dir);
+        if (dirStr === '/workspace') {
+          return [
+            { name: 'node_modules', isDirectory: () => true },
+            { name: '.git', isDirectory: () => true },
+            { name: 'project-a', isDirectory: () => true },
+          ] as unknown as ReturnType<typeof fs.readdir>;
+        }
+        return [] as unknown as ReturnType<typeof fs.readdir>;
+      });
+
+      const results = await discoverAllRunDirs();
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe('discoverAllRunsParentDirs', () => {
+    it('returns accessible source paths for depth=0 sources', async () => {
+      mockGetConfig.mockResolvedValue({
+        sources: [{ path: '/direct/runs', depth: 0 }],
+        port: 4800,
+        pollInterval: 2000,
+        theme: 'dark',
+        staleThresholdMs: 3600000,
+        recentCompletionWindowMs: 14400000,
+        retentionDays: 30,
+        hiddenProjects: [],
+      });
+
+      mockAccess.mockResolvedValue(undefined);
+
+      const dirs = await discoverAllRunsParentDirs();
+      expect(dirs).toContain('/direct/runs');
+    });
+
+    it('returns empty for inaccessible depth=0 sources', async () => {
+      mockGetConfig.mockResolvedValue({
+        sources: [{ path: '/nonexistent', depth: 0 }],
+        port: 4800,
+        pollInterval: 2000,
+        theme: 'dark',
+        staleThresholdMs: 3600000,
+        recentCompletionWindowMs: 14400000,
+        retentionDays: 30,
+        hiddenProjects: [],
+      });
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      mockAccess.mockRejectedValue(new Error('ENOENT'));
+
+      const dirs = await discoverAllRunsParentDirs();
+      expect(dirs).toHaveLength(0);
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/src/lib/__tests__/utils.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest';
+import {
+  formatDuration,
+  formatTimestamp,
+  truncateId,
+  getStatusColor,
+  getStatusBg,
+  formatShortId,
+  friendlyProcessName,
+} from '../utils';
+
+describe('formatDuration', () => {
+  it('returns dash for null/undefined', () => {
+    expect(formatDuration(null)).toBe('\u2014');
+    expect(formatDuration(undefined)).toBe('\u2014');
+  });
+
+  it('returns dash for negative values', () => {
+    expect(formatDuration(-100)).toBe('\u2014');
+  });
+
+  it('returns "<1s" for zero', () => {
+    expect(formatDuration(0)).toBe('<1s');
+  });
+
+  it('formats milliseconds', () => {
+    expect(formatDuration(500)).toBe('500ms');
+  });
+
+  it('formats seconds', () => {
+    expect(formatDuration(5000)).toBe('5s');
+    expect(formatDuration(59000)).toBe('59s');
+  });
+
+  it('formats minutes and seconds', () => {
+    expect(formatDuration(90000)).toBe('1m 30s');
+    expect(formatDuration(3599000)).toBe('59m 59s');
+  });
+
+  it('formats hours and minutes', () => {
+    expect(formatDuration(3600000)).toBe('1h 0m');
+    expect(formatDuration(7260000)).toBe('2h 1m');
+  });
+});
+
+describe('formatTimestamp', () => {
+  it('returns dash for undefined', () => {
+    expect(formatTimestamp(undefined)).toBe('\u2014');
+  });
+
+  it('formats a valid ISO string', () => {
+    const result = formatTimestamp('2024-01-15T14:30:00Z');
+    // Result depends on locale, just verify it returns something non-dash
+    expect(result).not.toBe('\u2014');
+    expect(result.length).toBeGreaterThan(0);
+  });
+});
+
+describe('truncateId', () => {
+  it('returns dash for empty string', () => {
+    expect(truncateId('')).toBe('\u2014');
+  });
+
+  it('returns full string when within limit', () => {
+    expect(truncateId('short')).toBe('short');
+  });
+
+  it('truncates and appends ellipsis', () => {
+    const longId = 'abcdefghijklmnopqrstuvwxyz';
+    expect(truncateId(longId)).toBe('abcdefghijkl...');
+    expect(truncateId(longId, 5)).toBe('abcde...');
+  });
+});
+
+describe('getStatusColor', () => {
+  it('returns success class for completed/resolved/ok', () => {
+    expect(getStatusColor('completed')).toBe('text-success');
+    expect(getStatusColor('resolved')).toBe('text-success');
+    expect(getStatusColor('ok')).toBe('text-success');
+  });
+
+  it('returns error class for failed/error', () => {
+    expect(getStatusColor('failed')).toBe('text-error');
+    expect(getStatusColor('error')).toBe('text-error');
+  });
+
+  it('returns pending class for waiting/pending', () => {
+    expect(getStatusColor('waiting')).toBe('text-pending');
+    expect(getStatusColor('pending')).toBe('text-pending');
+  });
+
+  it('returns info class for running/requested', () => {
+    expect(getStatusColor('running')).toBe('text-info');
+    expect(getStatusColor('requested')).toBe('text-info');
+  });
+
+  it('returns muted class for unknown status', () => {
+    expect(getStatusColor('whatever')).toBe('text-foreground-muted');
+  });
+});
+
+describe('getStatusBg', () => {
+  it('returns success bg for completed/resolved/ok', () => {
+    expect(getStatusBg('completed')).toBe('bg-success-muted');
+    expect(getStatusBg('resolved')).toBe('bg-success-muted');
+    expect(getStatusBg('ok')).toBe('bg-success-muted');
+  });
+
+  it('returns error bg for failed/error', () => {
+    expect(getStatusBg('failed')).toBe('bg-error-muted');
+    expect(getStatusBg('error')).toBe('bg-error-muted');
+  });
+
+  it('returns pending bg for waiting/pending', () => {
+    expect(getStatusBg('waiting')).toBe('bg-pending-muted');
+    expect(getStatusBg('pending')).toBe('bg-pending-muted');
+  });
+
+  it('returns info bg for running/requested', () => {
+    expect(getStatusBg('running')).toBe('bg-info-muted');
+    expect(getStatusBg('requested')).toBe('bg-info-muted');
+  });
+
+  it('returns default bg for unknown status', () => {
+    expect(getStatusBg('whatever')).toBe('bg-muted');
+  });
+});
+
+describe('formatShortId', () => {
+  it('returns dash for empty string', () => {
+    expect(formatShortId('')).toBe('\u2014');
+  });
+
+  it('returns full string when within limit', () => {
+    expect(formatShortId('abcd')).toBe('abcd');
+  });
+
+  it('shows last N chars with leading ellipsis', () => {
+    expect(formatShortId('abcdefgh')).toBe('...efgh');
+    expect(formatShortId('abcdefgh', 6)).toBe('...cdefgh');
+  });
+});
+
+describe('friendlyProcessName', () => {
+  it('returns empty string for empty input', () => {
+    expect(friendlyProcessName('')).toBe('');
+  });
+
+  it('capitalizes hyphen-separated words', () => {
+    expect(friendlyProcessName('data-pipeline')).toBe('Data Pipeline');
+  });
+
+  it('capitalizes slash-separated words', () => {
+    expect(friendlyProcessName('data-pipeline/ingest')).toBe('Data Pipeline Ingest');
+  });
+
+  it('handles single word', () => {
+    expect(friendlyProcessName('deploy')).toBe('Deploy');
+  });
+});

package/src/lib/__tests__/watcher.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { promises as fsPromises } from 'fs';
+
+// Mock source-discovery (watcher.ts imports directly from source-discovery)
+vi.mock('../source-discovery', () => ({
+  discoverAllRunDirs: vi.fn(),
+  invalidateDiscoveryCache: vi.fn(),
+  discoverAllRunsParentDirs: vi.fn().mockResolvedValue([]),
+}));
+
+// Mock run-cache
+vi.mock('../run-cache', () => ({
+  invalidateRun: vi.fn(),
+  requestDiscovery: vi.fn(),
+}));
+
+import { discoverAllRunDirs } from '../source-discovery';
+import { invalidateRun } from '../run-cache';
+import { initWatcher, watcherEvents, getWatcherStats } from '../watcher';
+
+const mockDiscoverAllRunDirs = vi.mocked(discoverAllRunDirs);
+const _mockInvalidateRun = vi.mocked(invalidateRun);
+const mockAccess = vi.spyOn(fsPromises, 'access');
+
+describe('watcher', () => {
+  let cleanupFn: (() => void) | null = null;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.useFakeTimers();
+    watcherEvents.removeAllListeners();
+    cleanupFn = null;
+  });
+
+  afterEach(() => {
+    if (cleanupFn) {
+      cleanupFn();
+      cleanupFn = null;
+    }
+    vi.useRealTimers();
+  });
+
+  describe('initWatcher', () => {
+    it('returns a cleanup function', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      expect(typeof cleanupFn).toBe('function');
+    });
+
+    it('does not throw when discovered dirs have no journal directories', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([
+        {
+          runDir: '/project/.a5c/runs/run-001',
+          source: { path: '/project', depth: 2 },
+          projectName: 'project',
+          projectPath: '/project',
+        },
+      ]);
+
+      // Journal dir does not exist
+      mockAccess.mockRejectedValue(new Error('ENOENT'));
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      expect(cleanupFn).toBeDefined();
+    });
+  });
+
+  describe('cleanup', () => {
+    it('removes all event listeners from watcherEvents', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      // Add a listener
+      watcherEvents.on('change', () => {});
+      expect(watcherEvents.listenerCount('change')).toBeGreaterThan(0);
+
+      cleanupFn();
+      expect(watcherEvents.listenerCount('change')).toBe(0);
+      cleanupFn = null;
+    });
+
+    it('can be called multiple times safely', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      // Call cleanup twice - should not throw
+      cleanupFn();
+      // After first cleanup, listeners are removed
+      expect(watcherEvents.listenerCount('change')).toBe(0);
+      cleanupFn = null;
+    });
+  });
+
+  describe('getWatcherStats', () => {
+    it('returns stats about active watchers', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      const stats = getWatcherStats();
+
+      expect(stats).toHaveProperty('activeWatchers');
+      expect(stats).toHaveProperty('watchedPaths');
+      expect(stats).toHaveProperty('pendingDebounces');
+      expect(typeof stats.activeWatchers).toBe('number');
+      expect(Array.isArray(stats.watchedPaths)).toBe(true);
+      expect(typeof stats.pendingDebounces).toBe('number');
+    });
+
+    it('has zero active watchers when no runs discovered', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      const stats = getWatcherStats();
+      expect(stats.activeWatchers).toBe(0);
+      expect(stats.watchedPaths).toHaveLength(0);
+    });
+
+    it('shows zero pending debounces initially', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      const stats = getWatcherStats();
+      expect(stats.pendingDebounces).toBe(0);
+    });
+  });
+
+  describe('watcherEvents', () => {
+    it('is an EventEmitter', () => {
+      expect(typeof watcherEvents.on).toBe('function');
+      expect(typeof watcherEvents.emit).toBe('function');
+      expect(typeof watcherEvents.removeAllListeners).toBe('function');
+    });
+
+    it('can register and emit change events', () => {
+      const handler = vi.fn();
+      watcherEvents.on('change', handler);
+
+      watcherEvents.emit('change', { type: 'run-changed', runDir: '/test' });
+
+      expect(handler).toHaveBeenCalledTimes(1);
+      expect(handler).toHaveBeenCalledWith({ type: 'run-changed', runDir: '/test' });
+    });
+
+    it('supports multiple listeners', () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      watcherEvents.on('change', handler1);
+      watcherEvents.on('change', handler2);
+
+      watcherEvents.emit('change', { type: 'new-run', runDir: '/test' });
+
+      expect(handler1).toHaveBeenCalledTimes(1);
+      expect(handler2).toHaveBeenCalledTimes(1);
+    });
+
+    it('supports different event types', () => {
+      const handler = vi.fn();
+      watcherEvents.on('change', handler);
+
+      watcherEvents.emit('change', { type: 'run-changed', runDir: '/r1' });
+      watcherEvents.emit('change', { type: 'new-run', runDir: '/r2' });
+      watcherEvents.emit('change', { type: 'error', runDir: '/r3', error: new Error('fail') });
+
+      expect(handler).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('periodic rescan', () => {
+    it('schedules periodic rescans via setInterval', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      // discoverAllRunDirs was called once during init
+      const initialCalls = mockDiscoverAllRunDirs.mock.calls.length;
+
+      // Advance past the 120s rescan interval (RESCAN_INTERVAL_MS = 120000)
+      vi.advanceTimersByTime(121000);
+
+      // Should have been called again for the rescan
+      expect(mockDiscoverAllRunDirs.mock.calls.length).toBeGreaterThan(initialCalls);
+    });
+
+    it('stops periodic rescan after cleanup', async () => {
+      mockDiscoverAllRunDirs.mockResolvedValue([]);
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      cleanupFn = await initWatcher();
+      consoleSpy.mockRestore();
+
+      const callsBeforeCleanup = mockDiscoverAllRunDirs.mock.calls.length;
+
+      cleanupFn();
+      cleanupFn = null;
+
+      // Advance well past rescan interval (RESCAN_INTERVAL_MS = 120000)
+      vi.advanceTimersByTime(240000);
+
+      // No additional calls should have been made
+      expect(mockDiscoverAllRunDirs.mock.calls.length).toBe(callsBeforeCleanup);
+    });
+  });
+});

package/src/lib/cn.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}