@yancyyu/openhermit 1.5.8

package/src/renderer/services/composerDraftStorage.ts

@@ -0,0 +1,271 @@
+/**
+ * Atomic draft storage for MessageComposer snapshots.
+ *
+ * Unlike `draftStorage.ts` (text-only with TTL), this stores a unified
+ * snapshot of text + chips + attachments under a single key — no TTL.
+ * Drafts persist until explicitly cleared (on send or manual action).
+ */
+
+import { del, get, set } from 'idb-keyval';
+
+import type { InlineChip } from '@renderer/types/inlineChip';
+import type { AgentActionMode, AttachmentPayload } from '@shared/types';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Current snapshot schema version. Bump when shape changes. */
+const SNAPSHOT_VERSION = 1;
+
+export interface ComposerDraftSnapshot {
+  version: number;
+  teamName: string;
+  text: string;
+  chips: InlineChip[];
+  attachments: AttachmentPayload[];
+  actionMode?: AgentActionMode;
+  updatedAt: number;
+}
+
+// ---------------------------------------------------------------------------
+// Key helpers
+// ---------------------------------------------------------------------------
+
+const KEY_PREFIX = 'composer:';
+
+function storageKey(teamName: string): string {
+  return `${KEY_PREFIX}${teamName}`;
+}
+
+/** Legacy keys used by the old three-key approach. */
+function legacyKeys(teamName: string): { text: string; chips: string; attachments: string } {
+  return {
+    text: `draft:compose:${teamName}`,
+    chips: `draft:compose:${teamName}:chips`,
+    attachments: `draft:compose:${teamName}:attachments`,
+  } as const;
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+function isValidSnapshot(data: unknown): data is ComposerDraftSnapshot {
+  if (typeof data !== 'object' || data === null) return false;
+  const obj = data as Record<string, unknown>;
+  return (
+    typeof obj.version === 'number' &&
+    typeof obj.teamName === 'string' &&
+    typeof obj.text === 'string' &&
+    Array.isArray(obj.chips) &&
+    Array.isArray(obj.attachments) &&
+    typeof obj.updatedAt === 'number'
+  );
+}
+
+// ---------------------------------------------------------------------------
+// IDB availability tracking (same pattern as draftStorage.ts)
+// ---------------------------------------------------------------------------
+
+let idbUnavailable = false;
+let idbUnavailableLogged = false;
+const fallbackStore = new Map<string, ComposerDraftSnapshot>();
+
+function markIdbUnavailable(): void {
+  if (!idbUnavailableLogged) {
+    idbUnavailableLogged = true;
+    console.warn(
+      '[composerDraftStorage] IndexedDB unavailable, using in-memory storage for this session.'
+    );
+  }
+  idbUnavailable = true;
+}
+
+// ---------------------------------------------------------------------------
+// Core API
+// ---------------------------------------------------------------------------
+
+async function saveSnapshot(teamName: string, snapshot: ComposerDraftSnapshot): Promise<void> {
+  const key = storageKey(teamName);
+  if (idbUnavailable) {
+    fallbackStore.set(key, snapshot);
+    return;
+  }
+  try {
+    await set(key, snapshot);
+  } catch {
+    markIdbUnavailable();
+    fallbackStore.set(key, snapshot);
+  }
+}
+
+async function loadSnapshot(teamName: string): Promise<ComposerDraftSnapshot | null> {
+  const key = storageKey(teamName);
+  if (idbUnavailable) {
+    return fallbackStore.get(key) ?? null;
+  }
+  try {
+    const data = await get<unknown>(key);
+    if (data == null) return null;
+    if (isValidSnapshot(data)) return data;
+    // Invalid shape — discard silently
+    void del(key);
+    return null;
+  } catch {
+    markIdbUnavailable();
+    return fallbackStore.get(key) ?? null;
+  }
+}
+
+async function deleteSnapshot(teamName: string): Promise<void> {
+  const key = storageKey(teamName);
+  if (idbUnavailable) {
+    fallbackStore.delete(key);
+    return;
+  }
+  try {
+    await del(key);
+  } catch {
+    markIdbUnavailable();
+    fallbackStore.delete(key);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Legacy migration
+// ---------------------------------------------------------------------------
+
+interface LegacyTextDraft {
+  value: string;
+  timestamp: number;
+}
+
+function isLegacyTextDraft(d: unknown): d is LegacyTextDraft {
+  if (typeof d !== 'object' || d === null) return false;
+  const obj = d as Record<string, unknown>;
+  return typeof obj.value === 'string' && typeof obj.timestamp === 'number';
+}
+
+function isValidChipArray(data: unknown): data is InlineChip[] {
+  if (!Array.isArray(data)) return false;
+  return data.every((raw) => {
+    if (typeof raw !== 'object' || raw === null) return false;
+    const item = raw as Record<string, unknown>;
+    return typeof item.id === 'string' && typeof item.filePath === 'string';
+  });
+}
+
+function isValidAttachmentArray(data: unknown): data is AttachmentPayload[] {
+  if (!Array.isArray(data)) return false;
+  return data.every((raw) => {
+    if (typeof raw !== 'object' || raw === null) return false;
+    const item = raw as Record<string, unknown>;
+    return (
+      typeof item.id === 'string' &&
+      typeof item.filename === 'string' &&
+      typeof item.data === 'string'
+    );
+  });
+}
+
+/**
+ * Attempts to migrate legacy three-key drafts into a unified snapshot.
+ * Returns the migrated snapshot or null if no legacy data found.
+ * Deletes legacy keys on success.
+ */
+async function migrateLegacy(teamName: string): Promise<ComposerDraftSnapshot | null> {
+  if (idbUnavailable) return null;
+
+  const keys = legacyKeys(teamName);
+
+  try {
+    const [rawText, rawChips, rawAttachments] = await Promise.all([
+      get<unknown>(keys.text),
+      get<unknown>(keys.chips),
+      get<unknown>(keys.attachments),
+    ]);
+
+    // Nothing to migrate
+    if (rawText == null && rawChips == null && rawAttachments == null) return null;
+
+    let text = '';
+    if (isLegacyTextDraft(rawText)) {
+      text = rawText.value;
+    }
+
+    let chips: InlineChip[] = [];
+    if (rawChips != null) {
+      const chipsData = typeof rawChips === 'string' ? (JSON.parse(rawChips) as unknown) : rawChips;
+      // Legacy text draft wraps value in {value, timestamp}
+      const unwrapped = isLegacyTextDraft(chipsData) ? chipsData.value : chipsData;
+      const toParse =
+        typeof unwrapped === 'string' ? (JSON.parse(unwrapped) as unknown) : unwrapped;
+      if (isValidChipArray(toParse)) chips = toParse;
+    }
+
+    let attachments: AttachmentPayload[] = [];
+    if (rawAttachments != null) {
+      const attData =
+        typeof rawAttachments === 'string'
+          ? (JSON.parse(rawAttachments) as unknown)
+          : rawAttachments;
+      const unwrapped = isLegacyTextDraft(attData) ? attData.value : attData;
+      const toParse =
+        typeof unwrapped === 'string' ? (JSON.parse(unwrapped) as unknown) : unwrapped;
+      if (isValidAttachmentArray(toParse)) attachments = toParse;
+    }
+
+    // Only create snapshot if there's actual content
+    if (text.length === 0 && chips.length === 0 && attachments.length === 0) {
+      // Clean up empty legacy keys
+      await Promise.all([del(keys.text), del(keys.chips), del(keys.attachments)]);
+      return null;
+    }
+
+    const snapshot: ComposerDraftSnapshot = {
+      version: SNAPSHOT_VERSION,
+      teamName,
+      text,
+      chips,
+      attachments,
+      updatedAt: Date.now(),
+    };
+
+    // Save new snapshot and delete legacy keys atomically-ish
+    await saveSnapshot(teamName, snapshot);
+    await Promise.all([del(keys.text), del(keys.chips), del(keys.attachments)]);
+
+    return snapshot;
+  } catch {
+    // Migration is best-effort — don't block the composer
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory for empty snapshot
+// ---------------------------------------------------------------------------
+
+function emptySnapshot(teamName: string): ComposerDraftSnapshot {
+  return {
+    version: SNAPSHOT_VERSION,
+    teamName,
+    text: '',
+    chips: [],
+    attachments: [],
+    updatedAt: Date.now(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+
+export const composerDraftStorage = {
+  saveSnapshot,
+  loadSnapshot,
+  deleteSnapshot,
+  migrateLegacy,
+  emptySnapshot,
+};

package/src/renderer/services/contextStorage.ts

@@ -0,0 +1,201 @@
+/**
+ * Context Storage - IndexedDB persistence layer for context snapshots.
+ *
+ * Provides TTL-based storage for workspace state snapshots, enabling
+ * instant restoration when switching between local and SSH contexts.
+ */
+
+import { del, get, keys, set } from 'idb-keyval';
+
+import type { DetectedError, Project, RepositoryGroup, Session } from '@renderer/types/data';
+import type { PaneLayout } from '@renderer/types/panes';
+import type { Tab } from '@renderer/types/tabs';
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const SNAPSHOT_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const STORAGE_KEY_PREFIX = 'context-snapshot:';
+const SNAPSHOT_VERSION = 1; // Increment when ContextSnapshot structure changes
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/**
+ * Context snapshot - persistable state for instant workspace switching.
+ * Excludes transient state (loading flags, errors, search, non-serializable Maps/Sets).
+ */
+export interface ContextSnapshot {
+  // Data state (persistable)
+  projects: Project[];
+  selectedProjectId: string | null;
+  repositoryGroups: RepositoryGroup[];
+  selectedRepositoryId: string | null;
+  selectedWorktreeId: string | null;
+  viewMode: 'flat' | 'grouped';
+  sessions: Session[];
+  selectedSessionId: string | null;
+  sessionsCursor: string | null;
+  sessionsHasMore: boolean;
+  sessionsTotalCount: number;
+  pinnedSessionIds: string[];
+  notifications: DetectedError[];
+  unreadCount: number;
+
+  // Tab/pane state
+  openTabs: Tab[];
+  activeTabId: string | null;
+  selectedTabIds: string[];
+  activeProjectId: string | null;
+  paneLayout: PaneLayout;
+
+  // UI state
+  sidebarCollapsed: boolean;
+
+  // Metadata
+  _metadata: {
+    contextId: string;
+    capturedAt: number;
+    version: number;
+  };
+}
+
+/**
+ * Stored snapshot - wraps ContextSnapshot with timestamp and version.
+ */
+interface StoredSnapshot {
+  snapshot: ContextSnapshot;
+  timestamp: number;
+  version: number;
+}
+
+// =============================================================================
+// Storage Implementation
+// =============================================================================
+
+/**
+ * Save a context snapshot to IndexedDB.
+ */
+async function saveSnapshot(contextId: string, snapshot: ContextSnapshot): Promise<void> {
+  try {
+    const stored: StoredSnapshot = {
+      snapshot,
+      timestamp: Date.now(),
+      version: SNAPSHOT_VERSION,
+    };
+    const key = `${STORAGE_KEY_PREFIX}${contextId}`;
+    await set(key, stored);
+  } catch (error) {
+    console.error(`[contextStorage] Failed to save snapshot for ${contextId}:`, error);
+  }
+}
+
+/**
+ * Load a context snapshot from IndexedDB.
+ * Returns null if not found, expired, or invalid.
+ */
+async function loadSnapshot(contextId: string): Promise<ContextSnapshot | null> {
+  try {
+    const key = `${STORAGE_KEY_PREFIX}${contextId}`;
+    const stored = await get<StoredSnapshot>(key);
+
+    if (!stored) {
+      return null;
+    }
+
+    // Check TTL
+    const age = Date.now() - stored.timestamp;
+    if (age > SNAPSHOT_TTL_MS) {
+      // Expired - delete and return null
+      void deleteSnapshot(contextId);
+      return null;
+    }
+
+    // Check version compatibility (simple check for now)
+    if (stored.version !== SNAPSHOT_VERSION) {
+      console.warn(
+        `[contextStorage] Snapshot version mismatch for ${contextId}: expected ${SNAPSHOT_VERSION}, got ${stored.version}`
+      );
+      void deleteSnapshot(contextId);
+      return null;
+    }
+
+    return stored.snapshot;
+  } catch (error) {
+    console.error(`[contextStorage] Failed to load snapshot for ${contextId}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Delete a context snapshot from IndexedDB.
+ */
+async function deleteSnapshot(contextId: string): Promise<void> {
+  try {
+    const key = `${STORAGE_KEY_PREFIX}${contextId}`;
+    await del(key);
+  } catch (error) {
+    console.error(`[contextStorage] Failed to delete snapshot for ${contextId}:`, error);
+  }
+}
+
+/**
+ * Clean up expired snapshots.
+ * Iterates all context snapshots and deletes expired ones.
+ */
+async function cleanupExpired(): Promise<void> {
+  try {
+    const allKeys = await keys();
+    const snapshotKeys = allKeys.filter(
+      (k): k is IDBValidKey & string => typeof k === 'string' && k.startsWith(STORAGE_KEY_PREFIX)
+    );
+
+    const now = Date.now();
+
+    for (const key of snapshotKeys) {
+      try {
+        const stored = await get<StoredSnapshot>(key);
+        if (stored) {
+          const age = now - stored.timestamp;
+          if (age > SNAPSHOT_TTL_MS) {
+            await del(key);
+          }
+        }
+      } catch (error) {
+        // Skip individual key errors
+        console.error(`[contextStorage] Failed to check/delete key ${String(key)}:`, error);
+      }
+    }
+  } catch (error) {
+    console.error('[contextStorage] Failed to cleanup expired snapshots:', error);
+  }
+}
+
+/**
+ * Check if IndexedDB is available.
+ * Returns true if storage is accessible, false otherwise.
+ */
+async function isAvailable(): Promise<boolean> {
+  try {
+    const testKey = '__idb_test__';
+    await set(testKey, true);
+    await del(testKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// =============================================================================
+// Exports
+// =============================================================================
+
+export const contextStorage = {
+  saveSnapshot,
+  loadSnapshot,
+  deleteSnapshot,
+  cleanupExpired,
+  isAvailable,
+};

package/src/renderer/services/createTeamDraftStorage.ts

@@ -0,0 +1,151 @@
+/**
+ * Atomic draft storage for CreateTeamDialog form snapshots.
+ *
+ * Stores the form state (team name, paths, color) under a single IndexedDB
+ * key so navigating away from the Teams tab and back preserves user input.
+ * No TTL — drafts persist until explicitly cleared on successful team creation.
+ *
+ * Pattern mirrors `composerDraftStorage.ts`.
+ */
+
+import { del, get, set } from 'idb-keyval';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * Current snapshot schema version. Bump when shape changes.
+ *
+ * v2 (2026-05-22): dropped `members`, `syncModelsWithLead`,
+ * `teammateWorktreeDefault`, `soloTeam`, `launchTeam` — workspace-scoped
+ * teams have no upfront roster and always auto-launch.
+ */
+const SNAPSHOT_VERSION = 2;
+
+export interface CreateTeamDraftSnapshot {
+  version: number;
+  teamName: string;
+  cwdMode: 'project' | 'custom';
+  selectedProjectPath: string;
+  customCwd: string;
+  teamColor: string;
+  updatedAt: number;
+}
+
+// ---------------------------------------------------------------------------
+// Key
+// ---------------------------------------------------------------------------
+
+const STORAGE_KEY = 'createTeamDraft:form';
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+function isValidSnapshot(data: unknown): data is CreateTeamDraftSnapshot {
+  if (typeof data !== 'object' || data === null) return false;
+  const obj = data as Record<string, unknown>;
+  return (
+    typeof obj.version === 'number' &&
+    obj.version === SNAPSHOT_VERSION &&
+    typeof obj.teamName === 'string' &&
+    (obj.cwdMode === 'project' || obj.cwdMode === 'custom') &&
+    typeof obj.selectedProjectPath === 'string' &&
+    typeof obj.customCwd === 'string' &&
+    typeof obj.teamColor === 'string' &&
+    typeof obj.updatedAt === 'number'
+  );
+}
+
+// ---------------------------------------------------------------------------
+// IDB availability tracking
+// ---------------------------------------------------------------------------
+
+let idbUnavailable = false;
+let idbUnavailableLogged = false;
+const fallbackStore = new Map<string, CreateTeamDraftSnapshot>();
+
+function markIdbUnavailable(): void {
+  if (!idbUnavailableLogged) {
+    idbUnavailableLogged = true;
+    console.warn(
+      '[createTeamDraftStorage] IndexedDB unavailable, using in-memory storage for this session.'
+    );
+  }
+  idbUnavailable = true;
+}
+
+// ---------------------------------------------------------------------------
+// Core API
+// ---------------------------------------------------------------------------
+
+async function saveSnapshot(snapshot: CreateTeamDraftSnapshot): Promise<void> {
+  if (idbUnavailable) {
+    fallbackStore.set(STORAGE_KEY, snapshot);
+    return;
+  }
+  try {
+    await set(STORAGE_KEY, snapshot);
+  } catch {
+    markIdbUnavailable();
+    fallbackStore.set(STORAGE_KEY, snapshot);
+  }
+}
+
+async function loadSnapshot(): Promise<CreateTeamDraftSnapshot | null> {
+  if (idbUnavailable) {
+    return fallbackStore.get(STORAGE_KEY) ?? null;
+  }
+  try {
+    const data = await get<unknown>(STORAGE_KEY);
+    if (data == null) return null;
+    if (isValidSnapshot(data)) return data;
+    // Invalid shape (including older versions) — discard silently
+    void del(STORAGE_KEY);
+    return null;
+  } catch {
+    markIdbUnavailable();
+    return fallbackStore.get(STORAGE_KEY) ?? null;
+  }
+}
+
+async function deleteSnapshot(): Promise<void> {
+  if (idbUnavailable) {
+    fallbackStore.delete(STORAGE_KEY);
+    return;
+  }
+  try {
+    await del(STORAGE_KEY);
+  } catch {
+    markIdbUnavailable();
+    fallbackStore.delete(STORAGE_KEY);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+function emptySnapshot(): CreateTeamDraftSnapshot {
+  return {
+    version: SNAPSHOT_VERSION,
+    teamName: '',
+    cwdMode: 'project',
+    selectedProjectPath: '',
+    customCwd: '',
+    teamColor: '',
+    updatedAt: Date.now(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+
+export const createTeamDraftStorage = {
+  saveSnapshot,
+  loadSnapshot,
+  deleteSnapshot,
+  emptySnapshot,
+};