@yancyyu/openhermit 1.5.8

package/src/renderer/lib/utils.ts

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

package/src/renderer/main.tsx

@@ -0,0 +1,30 @@
+import './index.css';
+import 'react-grid-layout/css/styles.css';
+import 'react-resizable/css/styles.css';
+
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+
+import { App } from './App';
+import { initSentryRenderer } from './sentry';
+import { initializeNotificationListeners } from './store';
+
+declare global {
+  interface Window {
+    __claudeTeamsUiDidInit?: boolean;
+  }
+}
+
+// Sentry must be initialised before React renders.
+initSentryRenderer();
+
+if (!window.__claudeTeamsUiDidInit) {
+  window.__claudeTeamsUiDidInit = true;
+  initializeNotificationListeners();
+}
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);

package/src/renderer/sentry.ts

@@ -0,0 +1,104 @@
+/**
+ * Sentry initialisation for the **renderer** process.
+ *
+ * Must be called before `ReactDOM.createRoot()` in `main.tsx`.
+ * Supports both Electron (preload bridge) and standalone browser mode.
+ *
+ * When `VITE_SENTRY_DSN` is not set (dev / self-builds), everything is a no-op.
+ */
+
+import {
+  addBreadcrumb,
+  captureException,
+  init as reactInit,
+  browserTracingIntegration as reactBrowserTracing,
+  withScope,
+} from '@sentry/react';
+import {
+  isValidDsn,
+  SENTRY_ENVIRONMENT,
+  SENTRY_RELEASE,
+  TRACES_SAMPLE_RATE,
+} from '@shared/utils/sentryConfig';
+
+// ---------------------------------------------------------------------------
+// Telemetry gate (mirrors src/main/sentry.ts pattern)
+// ---------------------------------------------------------------------------
+
+// Defaults to `true` so early renderer crashes are captured.
+// Synced to user's telemetryEnabled preference via syncRendererTelemetry().
+let telemetryAllowed = true;
+let initialized = false;
+
+/**
+ * Sync the opt-in flag from config. Call after config is loaded
+ * and whenever the user toggles telemetry in Settings.
+ */
+export function syncRendererTelemetry(enabled: boolean): void {
+  telemetryAllowed = enabled;
+}
+
+export function initSentryRenderer(): void {
+  if (initialized) return;
+
+  const dsn = import.meta.env.VITE_SENTRY_DSN as string | undefined;
+  if (!isValidDsn(dsn)) return;
+
+  const baseOptions = {
+    dsn,
+    release: SENTRY_RELEASE,
+    environment: SENTRY_ENVIRONMENT,
+    tracesSampleRate: TRACES_SAMPLE_RATE,
+    sendDefaultPii: false,
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- cross-version @sentry/core type mismatch
+  const beforeSend = (event: any): any => (telemetryAllowed ? event : null);
+
+  // Web browser mode — direct HTTP transport
+  reactInit({
+    ...baseOptions,
+    beforeSend,
+    integrations: [reactBrowserTracing()],
+  });
+
+  initialized = true;
+}
+
+/** Whether the renderer SDK was successfully initialised. */
+export function isSentryRendererActive(): boolean {
+  return initialized;
+}
+
+// ---------------------------------------------------------------------------
+// Public helpers (no-op when Sentry is not configured)
+// ---------------------------------------------------------------------------
+
+/** Record a navigation breadcrumb (tab switches). */
+export function addNavigationBreadcrumb(from: string, to: string): void {
+  if (!initialized) return;
+  addBreadcrumb({
+    category: 'navigation',
+    message: `Tab: ${from} → ${to}`,
+    level: 'info',
+  });
+}
+
+/** Record a generic breadcrumb from the renderer. */
+export function addRendererBreadcrumb(
+  category: string,
+  message: string,
+  data?: Record<string, unknown>
+): void {
+  if (!initialized) return;
+  addBreadcrumb({ category, message, data, level: 'info' });
+}
+
+/** Capture an exception with optional extra context. */
+export function captureRendererException(error: Error, context?: Record<string, unknown>): void {
+  if (!initialized) return;
+  withScope((scope) => {
+    if (context) scope.setContext('react', context);
+    captureException(error);
+  });
+}

package/src/renderer/services/__tests__/createTeamPreferences.test.ts

@@ -0,0 +1,67 @@
+import {
+  applyStoredCreateTeamMemberRuntimePreferences,
+  getStoredCreateTeamMemberRuntimePreferences,
+  getStoredCreateTeamProvider,
+  setStoredCreateTeamMemberRuntimePreferences,
+} from '@renderer/services/createTeamPreferences';
+import { afterEach, describe, expect, it } from 'vitest';
+
+describe('createTeamPreferences', () => {
+  afterEach(() => {
+    localStorage.clear();
+  });
+
+  it('stores teammate runtime preferences and reapplies them by member name', () => {
+    setStoredCreateTeamMemberRuntimePreferences([
+      { name: 'alice', providerId: 'codex', model: 'gpt-5', effort: 'high' },
+      { name: 'tom' },
+    ]);
+
+    const restored = applyStoredCreateTeamMemberRuntimePreferences([
+      { name: 'alice', providerId: undefined, model: '', effort: undefined },
+      { name: 'tom', providerId: 'anthropic', model: 'opus', effort: 'medium' },
+      { name: 'bob', providerId: undefined, model: '', effort: undefined },
+    ]);
+
+    expect(getStoredCreateTeamMemberRuntimePreferences()).toEqual([
+      { name: 'alice', providerId: 'codex', model: 'gpt-5', effort: 'high' },
+      { name: 'tom', providerId: undefined, model: undefined, effort: undefined },
+    ]);
+    expect(restored).toEqual([
+      { name: 'alice', providerId: 'codex', model: 'gpt-5', effort: 'high' },
+      { name: 'tom', providerId: undefined, model: '', effort: undefined },
+      { name: 'bob', providerId: undefined, model: '', effort: undefined },
+    ]);
+  });
+
+  it('merges teammate runtime preferences instead of dropping omitted members', () => {
+    setStoredCreateTeamMemberRuntimePreferences([
+      { name: 'alice', providerId: 'codex', model: 'gpt-5', effort: 'high' },
+      { name: 'bob', providerId: 'opencode', model: 'openai/gpt-5.4', effort: 'low' },
+    ]);
+
+    setStoredCreateTeamMemberRuntimePreferences([
+      { name: 'alice', providerId: 'anthropic', model: 'haiku', effort: 'medium' },
+    ]);
+
+    expect(getStoredCreateTeamMemberRuntimePreferences()).toEqual([
+      { name: 'alice', providerId: 'anthropic', model: 'haiku', effort: 'medium' },
+      { name: 'bob', providerId: 'opencode', model: 'openai/gpt-5.4', effort: 'low' },
+    ]);
+  });
+
+  it('normalizes a stored OpenCode provider selection to anthropic for future create-team runs', () => {
+    localStorage.setItem('createTeam:lastSelectedProvider', 'opencode');
+
+    expect(getStoredCreateTeamProvider()).toBe('anthropic');
+  });
+
+  it('ignores invalid serialized preferences', () => {
+    localStorage.setItem(
+      'createTeam:lastMemberRuntimePreferences',
+      JSON.stringify({ version: 999, members: [{ name: 'alice', providerId: 'codex' }] })
+    );
+
+    expect(getStoredCreateTeamMemberRuntimePreferences()).toEqual([]);
+  });
+});

package/src/renderer/services/commentReadStorage.ts

@@ -0,0 +1,349 @@
+import { get, set } from 'idb-keyval';
+
+const IDB_KEY = 'comment-read-state-v2';
+const LS_KEY = 'comment-read-state-v2';
+const LEGACY_IDB_KEY = 'comment-read-state';
+const LEGACY_LS_KEY = 'comment-read-state';
+const SAVE_DEBOUNCE_MS = 300;
+const STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+
+/**
+ * Per-task read state: tracks individual comment IDs that have been seen.
+ * `lastUpdated` is used for stale cleanup (prune entries older than 30 days).
+ */
+interface TaskReadEntry {
+  readIds: string[];
+  lastUpdated: number;
+}
+
+type ReadState = Record<string, TaskReadEntry>; // key = "teamName/taskId"
+
+// Legacy format for migration (v1 stored a single timestamp per task)
+type LegacyReadState = Record<string, number>;
+
+// --- localStorage helpers ---
+function lsLoad(): ReadState | null {
+  try {
+    const raw = localStorage.getItem(LS_KEY);
+    if (!raw) return null;
+    const parsed: unknown = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+    return parsed as ReadState;
+  } catch {
+    return null;
+  }
+}
+
+function lsSave(state: ReadState): void {
+  try {
+    localStorage.setItem(LS_KEY, JSON.stringify(state));
+  } catch {
+    // localStorage full or unavailable — silently ignore
+  }
+}
+
+function lsLoadLegacy(): LegacyReadState | null {
+  try {
+    const raw = localStorage.getItem(LEGACY_LS_KEY);
+    if (!raw) return null;
+    const parsed: unknown = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+    // Verify it's the old format (values are numbers, not objects)
+    const entries = Object.entries(parsed as Record<string, unknown>);
+    if (entries.length > 0 && typeof entries[0][1] === 'number') {
+      return parsed as LegacyReadState;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Migrate legacy per-task timestamp to per-comment ID format.
+ * Since we don't have comment IDs from the old format, we treat all
+ * comments with timestamps <= the old lastRead as "read" by storing
+ * a sentinel marker. The actual per-comment tracking starts fresh.
+ */
+function migrateLegacy(legacy: LegacyReadState): ReadState {
+  const migrated: ReadState = {};
+  for (const [key, timestamp] of Object.entries(legacy)) {
+    if (typeof timestamp === 'number' && timestamp > 0) {
+      // Store legacy timestamp as a sentinel — getUnreadCount will use it
+      // for comments older than migration, and per-ID for newer ones.
+      migrated[key] = {
+        readIds: [],
+        lastUpdated: timestamp,
+      };
+    }
+  }
+  return migrated;
+}
+
+// Synchronous init from localStorage — guarantees first render sees read state
+let cache: ReadState = {};
+const v2Data = lsLoad();
+if (v2Data && Object.keys(v2Data).length > 0) {
+  cache = v2Data;
+} else {
+  const legacyData = lsLoadLegacy();
+  if (legacyData && Object.keys(legacyData).length > 0) {
+    cache = migrateLegacy(legacyData);
+  }
+}
+
+let loaded = Object.keys(cache).length > 0;
+let idbAvailable = true; // flips to false on first IndexedDB failure
+let saveTimer: ReturnType<typeof setTimeout> | null = null;
+const listeners = new Set<() => void>();
+
+// --- useSyncExternalStore API ---
+export function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  if (!loaded) void load();
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function getSnapshot(): ReadState {
+  return cache;
+}
+
+// --- Mutations ---
+
+/**
+ * Mark specific comment IDs as read for a given team/task.
+ */
+export function markCommentsRead(teamName: string, taskId: string, commentIds: string[]): void {
+  if (commentIds.length === 0) return;
+  const key = `${teamName}/${taskId}`;
+  const prev = cache[key];
+  const prevSet = new Set(prev?.readIds ?? []);
+  let changed = false;
+  for (const id of commentIds) {
+    if (!prevSet.has(id)) {
+      prevSet.add(id);
+      changed = true;
+    }
+  }
+  if (!changed) return;
+  cache = {
+    ...cache,
+    [key]: {
+      readIds: Array.from(prevSet),
+      lastUpdated: Date.now(),
+    },
+  };
+  notify();
+  scheduleSave();
+}
+
+/**
+ * @deprecated Use markCommentsRead() instead. Kept for backward compatibility
+ * with code that hasn't migrated yet (e.g. flush fallback).
+ */
+export function markAsRead(teamName: string, taskId: string, latestTimestamp: number): void {
+  const key = `${teamName}/${taskId}`;
+  const prev = cache[key];
+  // Update lastUpdated to at least this timestamp (for legacy migration support)
+  const prevLastUpdated = prev?.lastUpdated ?? 0;
+  if (latestTimestamp <= prevLastUpdated && prev) return;
+  cache = {
+    ...cache,
+    [key]: {
+      readIds: prev?.readIds ?? [],
+      lastUpdated: Math.max(prevLastUpdated, latestTimestamp),
+    },
+  };
+  notify();
+  scheduleSave();
+}
+
+/**
+ * Count unread comments for a task.
+ * A comment is unread if its ID is NOT in the readIds set.
+ *
+ * Legacy migration: when readIds is empty (data migrated from v1 timestamp
+ * format), comments created at or before the legacy cutoff are treated as read.
+ * Once any per-ID tracking starts (readIds non-empty), the cutoff is ignored
+ * — only explicit IDs determine read state. This prevents `lastUpdated`
+ * (which is refreshed by markCommentsRead on every save for stale-cleanup
+ * purposes) from accidentally marking ALL comments as read.
+ */
+export function getUnreadCount(
+  readState: ReadState,
+  teamName: string,
+  taskId: string,
+  comments: { id?: string; createdAt: string }[]
+): number {
+  if (!comments || comments.length === 0) return 0;
+  const key = `${teamName}/${taskId}`;
+  const entry = readState[key];
+  if (!entry) return comments.length;
+
+  const readSet = new Set(entry.readIds);
+  // Only use the timestamp cutoff for pure-legacy entries (no per-ID tracking yet).
+  // Once readIds is non-empty, per-ID tracking is authoritative and the timestamp
+  // must NOT be used — it gets refreshed to Date.now() on every save.
+  const legacyCutoff = readSet.size === 0 ? entry.lastUpdated : 0;
+
+  let count = 0;
+  for (const c of comments) {
+    // If comment has an ID and it's in the read set → read
+    if (c.id && readSet.has(c.id)) continue;
+    // Legacy-only: comment created before/at the migration cutoff → read
+    if (legacyCutoff > 0) {
+      const ts = new Date(c.createdAt).getTime();
+      if (ts <= legacyCutoff) continue;
+    }
+    // Otherwise → unread
+    count++;
+  }
+  return count;
+}
+
+/**
+ * Get the set of read comment IDs for a team/task pair.
+ */
+export function getReadCommentIds(teamName: string, taskId: string): Set<string> {
+  const key = `${teamName}/${taskId}`;
+  const entry = cache[key];
+  return new Set(entry?.readIds ?? []);
+}
+
+/**
+ * Get the legacy migration cutoff timestamp for a team/task pair (0 if none).
+ * Returns non-zero only for pure-legacy entries where readIds is empty.
+ * Once per-ID tracking has started (readIds non-empty), the cutoff is 0
+ * because lastUpdated gets refreshed to Date.now() on every save and
+ * would incorrectly mark all comments as read.
+ */
+export function getLegacyCutoff(teamName: string, taskId: string): number {
+  const key = `${teamName}/${taskId}`;
+  const entry = cache[key];
+  if (!entry) return 0;
+  // Only honour the timestamp when no per-ID tracking exists (pure legacy data).
+  if (entry.readIds.length > 0) return 0;
+  return entry.lastUpdated;
+}
+
+/** @deprecated Use getReadCommentIds() + getLegacyCutoff() instead. */
+export function getLastReadTimestamp(teamName: string, taskId: string): number {
+  const key = `${teamName}/${taskId}`;
+  return cache[key]?.lastUpdated ?? 0;
+}
+
+// --- Internal ---
+function hasIndexedDB(): boolean {
+  return typeof indexedDB !== 'undefined';
+}
+
+function notify(): void {
+  listeners.forEach((l) => l());
+}
+
+function scheduleSave(): void {
+  if (saveTimer) clearTimeout(saveTimer);
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    void save();
+  }, SAVE_DEBOUNCE_MS);
+}
+
+async function load(): Promise<void> {
+  if (loaded) return;
+
+  if (hasIndexedDB() && idbAvailable) {
+    try {
+      // Try v2 format first
+      const stored = await get<ReadState>(IDB_KEY);
+      if (stored && typeof stored === 'object') {
+        const merged = { ...cache };
+        for (const [k, v] of Object.entries(stored)) {
+          if (!v || typeof v !== 'object') continue;
+          const entry = v;
+          const prev = merged[k];
+          if (!prev) {
+            merged[k] = entry;
+          } else {
+            // Merge: union of readIds, max lastUpdated
+            const mergedIds = new Set([...prev.readIds, ...entry.readIds]);
+            merged[k] = {
+              readIds: Array.from(mergedIds),
+              lastUpdated: Math.max(prev.lastUpdated, entry.lastUpdated),
+            };
+          }
+        }
+        cache = merged;
+        notify();
+      } else {
+        // Try legacy IDB format
+        const legacy = await get<LegacyReadState>(LEGACY_IDB_KEY);
+        if (legacy && typeof legacy === 'object') {
+          const migrated = migrateLegacy(legacy);
+          const merged = { ...cache };
+          for (const [k, v] of Object.entries(migrated)) {
+            if (!merged[k]) {
+              merged[k] = v;
+            } else {
+              merged[k] = {
+                readIds: [...new Set([...merged[k].readIds, ...v.readIds])],
+                lastUpdated: Math.max(merged[k].lastUpdated, v.lastUpdated),
+              };
+            }
+          }
+          cache = merged;
+          notify();
+        }
+      }
+    } catch {
+      idbAvailable = false;
+    }
+  }
+
+  loaded = true;
+}
+
+async function save(): Promise<void> {
+  // Always write to localStorage (sync, reliable)
+  lsSave(cache);
+
+  // Also write to IndexedDB (async, primary)
+  if (idbAvailable && hasIndexedDB()) {
+    try {
+      await set(IDB_KEY, cache);
+    } catch {
+      idbAvailable = false;
+    }
+  }
+}
+
+export async function cleanupStale(): Promise<void> {
+  const now = Date.now();
+  let changed = false;
+  const result: ReadState = {};
+  for (const [k, v] of Object.entries(cache)) {
+    if (now - v.lastUpdated < STALE_THRESHOLD_MS) {
+      result[k] = v;
+    } else {
+      changed = true;
+    }
+  }
+
+  if (!changed) return;
+
+  // Update in-memory cache
+  cache = result;
+  notify();
+
+  // Persist to both storages
+  lsSave(result);
+  if (idbAvailable && hasIndexedDB()) {
+    try {
+      await set(IDB_KEY, result);
+    } catch {
+      idbAvailable = false;
+    }
+  }
+}