cache per-instance history via SSE

packages/ui/src/lib/storage.ts

@@ -4,12 +4,17 @@ import { cliEvents } from "./cli-events"
 
 export type ConfigData = AppConfig
 
+const DEFAULT_INSTANCE_DATA: InstanceData = {
+  messageHistory: [],
+}
+
 function isDeepEqual(a: unknown, b: unknown): boolean {
   if (a === b) {
     return true
   }
 
   if (typeof a === "object" && a !== null && typeof b === "object" && b !== null) {
+
     try {
       return JSON.stringify(a) === JSON.stringify(b)
     } catch (error) {
@@ -24,12 +29,20 @@ export class ServerStorage {
   private configChangeListeners: Set<(config: ConfigData) => void> = new Set()
   private configCache: ConfigData | null = null
   private loadPromise: Promise<ConfigData> | null = null
+  private instanceDataCache = new Map<string, InstanceData>()
+  private instanceDataListeners = new Map<string, Set<(data: InstanceData) => void>>()
+  private instanceLoadPromises = new Map<string, Promise<InstanceData>>()
 
   constructor() {
     cliEvents.on("config.appChanged", (event) => {
       if (event.type !== "config.appChanged") return
       this.setConfigCache(event.config)
     })
+
+    cliEvents.on("instance.dataChanged", (event) => {
+      if (event.type !== "instance.dataChanged") return
+      this.setInstanceDataCache(event.instanceId, event.data)
+    })
   }
 
   async loadConfig(): Promise<ConfigData> {
@@ -59,15 +72,38 @@ export class ServerStorage {
   }
 
   async loadInstanceData(instanceId: string): Promise<InstanceData> {
-    return cliApi.readInstanceData(instanceId)
+    const cached = this.instanceDataCache.get(instanceId)
+    if (cached) {
+      return cached
+    }
+
+    if (!this.instanceLoadPromises.has(instanceId)) {
+      const promise = cliApi
+        .readInstanceData(instanceId)
+        .then((data) => {
+          const normalized = this.normalizeInstanceData(data)
+          this.setInstanceDataCache(instanceId, normalized)
+          return normalized
+        })
+        .finally(() => {
+          this.instanceLoadPromises.delete(instanceId)
+        })
+
+      this.instanceLoadPromises.set(instanceId, promise)
+    }
+
+    return this.instanceLoadPromises.get(instanceId)!
   }
 
   async saveInstanceData(instanceId: string, data: InstanceData): Promise<void> {
-    await cliApi.writeInstanceData(instanceId, data)
+    const normalized = this.normalizeInstanceData(data)
+    await cliApi.writeInstanceData(instanceId, normalized)
+    this.setInstanceDataCache(instanceId, normalized)
   }
 
   async deleteInstanceData(instanceId: string): Promise<void> {
     await cliApi.deleteInstanceData(instanceId)
+    this.setInstanceDataCache(instanceId, DEFAULT_INSTANCE_DATA)
   }
 
   onConfigChanged(listener: (config: ConfigData) => void): () => void {
@@ -78,6 +114,24 @@ export class ServerStorage {
     return () => this.configChangeListeners.delete(listener)
   }
 
+  onInstanceDataChanged(instanceId: string, listener: (data: InstanceData) => void): () => void {
+    if (!this.instanceDataListeners.has(instanceId)) {
+      this.instanceDataListeners.set(instanceId, new Set())
+    }
+    const bucket = this.instanceDataListeners.get(instanceId)!
+    bucket.add(listener)
+    const cached = this.instanceDataCache.get(instanceId)
+    if (cached) {
+      listener(cached)
+    }
+    return () => {
+      bucket.delete(listener)
+      if (bucket.size === 0) {
+        this.instanceDataListeners.delete(instanceId)
+      }
+    }
+  }
+
   private setConfigCache(config: ConfigData) {
     if (this.configCache && isDeepEqual(this.configCache, config)) {
       this.configCache = config
@@ -92,6 +146,36 @@ export class ServerStorage {
       listener(config)
     }
   }
+
+  private normalizeInstanceData(data?: InstanceData | null): InstanceData {
+    const source = data ?? DEFAULT_INSTANCE_DATA
+    const messageHistory = Array.isArray(source.messageHistory) ? [...source.messageHistory] : []
+    return {
+      ...source,
+      messageHistory,
+    }
+  }
+
+  private setInstanceDataCache(instanceId: string, data: InstanceData) {
+    const normalized = this.normalizeInstanceData(data)
+    const previous = this.instanceDataCache.get(instanceId)
+    if (previous && isDeepEqual(previous, normalized)) {
+      this.instanceDataCache.set(instanceId, normalized)
+      return
+    }
+    this.instanceDataCache.set(instanceId, normalized)
+    this.notifyInstanceDataChanged(instanceId, normalized)
+  }
+
+  private notifyInstanceDataChanged(instanceId: string, data: InstanceData) {
+    const listeners = this.instanceDataListeners.get(instanceId)
+    if (!listeners) {
+      return
+    }
+    for (const listener of listeners) {
+      listener(data)
+    }
+  }
 }
 
 export const storage = new ServerStorage()

packages/ui/src/stores/message-history.ts

@@ -1,59 +1,88 @@
+import type { InstanceData } from "../../../cli/src/api-types"
 import { storage } from "../lib/storage"
 
 const MAX_HISTORY = 100
 
-const instanceHistories = new Map<string, string[]>()
-const historyLoaded = new Set<string>()
+const instanceDataCache = new Map<string, InstanceData>()
+const instanceSubscriptions = new Map<string, () => void>()
 
 export async function addToHistory(instanceId: string, text: string): Promise<void> {
-  await ensureHistoryLoaded(instanceId)
-
-  const history = instanceHistories.get(instanceId) || []
-
-  history.unshift(text)
-
-  if (history.length > MAX_HISTORY) {
-    history.length = MAX_HISTORY
+  const data = await ensureInstanceData(instanceId)
+  const nextHistory = [text, ...data.messageHistory]
+  if (nextHistory.length > MAX_HISTORY) {
+    nextHistory.length = MAX_HISTORY
   }
 
-  instanceHistories.set(instanceId, history)
+  const nextData: InstanceData = {
+    ...data,
+    messageHistory: nextHistory,
+  }
+
+  instanceDataCache.set(instanceId, cloneInstanceData(nextData))
 
   try {
-    await storage.saveInstanceData(instanceId, { messageHistory: history })
+    await storage.saveInstanceData(instanceId, nextData)
   } catch (err) {
     console.warn("Failed to persist message history:", err)
   }
 }
 
 export async function getHistory(instanceId: string): Promise<string[]> {
-  await ensureHistoryLoaded(instanceId)
-  return instanceHistories.get(instanceId) || []
+  const data = await ensureInstanceData(instanceId)
+  return [...data.messageHistory]
 }
 
 export async function clearHistory(instanceId: string): Promise<void> {
-  instanceHistories.delete(instanceId)
-  historyLoaded.delete(instanceId)
+  const data = await ensureInstanceData(instanceId)
+  const nextData: InstanceData = {
+    ...data,
+    messageHistory: [],
+  }
+
+  instanceDataCache.set(instanceId, cloneInstanceData(nextData))
 
   try {
-    await storage.saveInstanceData(instanceId, { messageHistory: [] })
+    await storage.saveInstanceData(instanceId, nextData)
   } catch (error) {
     console.warn("Failed to clear history:", error)
   }
 }
 
-async function ensureHistoryLoaded(instanceId: string): Promise<void> {
-  if (historyLoaded.has(instanceId)) {
-    return
+async function ensureInstanceData(instanceId: string): Promise<InstanceData> {
+  const cached = instanceDataCache.get(instanceId)
+  if (cached) {
+    return cached
   }
 
   try {
     const data = await storage.loadInstanceData(instanceId)
-    const history = Array.isArray(data.messageHistory) ? data.messageHistory : []
-    instanceHistories.set(instanceId, history)
-    historyLoaded.add(instanceId)
+    const normalized = cloneInstanceData(data)
+    instanceDataCache.set(instanceId, normalized)
+    attachInstanceSubscription(instanceId)
+    return normalized
   } catch (error) {
     console.warn("Failed to load history:", error)
-    instanceHistories.set(instanceId, [])
-    historyLoaded.add(instanceId)
+    const fallback = cloneInstanceData({ messageHistory: [] })
+    instanceDataCache.set(instanceId, fallback)
+    attachInstanceSubscription(instanceId)
+    return fallback
+  }
+}
+
+function attachInstanceSubscription(instanceId: string) {
+  if (instanceSubscriptions.has(instanceId)) {
+    return
+  }
+  const unsubscribe = storage.onInstanceDataChanged(instanceId, (data) => {
+    instanceDataCache.set(instanceId, cloneInstanceData(data))
+  })
+  instanceSubscriptions.set(instanceId, unsubscribe)
+}
+
+function cloneInstanceData(data?: InstanceData | null): InstanceData {
+  const source: InstanceData = data ?? { messageHistory: [] }
+  return {
+    ...source,
+    messageHistory: Array.isArray(source.messageHistory) ? [...source.messageHistory] : [],
   }
 }