Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
feat: add IndexedDB chat message cache for instant conversation display
Gus2f49186c44ee
diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex 4f039e80c..bbd83200a 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -246,6 +246,9 @@ importers:gsap:specifier: ^3.15.0version: 3.15.0+ idb:+ specifier: ^8.0.3+ version: 8.0.3input-otp:specifier: ^1.4.2@@ -319,6 +322,9 @@ importers:eslint-plugin-tailwind-canonical-classes:specifier: ^1.3.3version: 1.3.3([email protected]([email protected]))+ fake-indexeddb:+ specifier: ^6.2.5+ version: 6.2.5tailwindcss:specifier: ^4version: 4.3.0@@ -4399,6 +4405,10 @@ packages:engines: {node: '>= 10.17.0'}hasBin: true+ resolution: {integrity: sha512-CGnyrvbhPlWYMngksqrSSUT1BAVP49dZocrHuK0SvtR0D5TMs5wP0o3j7jexDJW01KSadjBp1M/71o/KR3nD1w==}+ engines: {node: '>=18'}+resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}@@ -4779,6 +4789,9 @@ packages:resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}engines: {node: '>=0.10.0'}+ resolution: {integrity: sha512-LtwtVyVYO5BqRvcsKuB2iUMnHwPVByPCXFXOpuU96IZPPoPN6xjOGxZQ74pgSVVLQWtUOYgyeL4GE98BY5D3wg==}+resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}engines: {node: '>= 4'}@@ -11682,6 +11695,8 @@ snapshots:transitivePeerDependencies:- supports-color+ [email protected]: {}+@@ -12142,6 +12157,8 @@ snapshots:dependencies:safer-buffer: 2.1.2+ [email protected]: {}+diff --git a/src/web/package.json b/src/web/package.jsonindex dc6b89c71..0fde7424c 100644--- a/src/web/package.json+++ b/src/web/package.json@@ -48,6 +48,7 @@"embla-carousel-autoplay": "^8.6.0","embla-carousel-react": "^8.6.0","gsap": "^3.15.0",+ "idb": "^8.0.3","input-otp": "^1.4.2","lucide-react": "^1.16.0","nanoid": "^5.1.11",@@ -74,6 +75,7 @@"eslint": "^9","eslint-config-next": "16.2.6","eslint-plugin-tailwind-canonical-classes": "^1.3.3",+ "fake-indexeddb": "^6.2.5","tailwindcss": "^4","tsx": "^4.22.1","typescript": "^6.0.3",diff --git a/src/web/src/app/(app)/studio/new/client.tsx b/src/web/src/app/(app)/studio/new/client.tsxindex 3432739bd..96828da07 100644--- a/src/web/src/app/(app)/studio/new/client.tsx+++ b/src/web/src/app/(app)/studio/new/client.tsx@@ -7,6 +7,7 @@ import { Input } from "@/components/ui/input";import { Loader2, CheckCircle2, XCircle, LogOut, ArrowLeft, LayoutGrid } from "lucide-react";import { toast } from "sonner";import { signOut } from "@/lib/auth-client";+import { clearAllCache } from "@/lib/chat-cache";import { ConnectMachineSteps } from "@/components/connect-machine-steps";import { ScenarioPicker } from "@/components/studio-onboarding/scenario-picker";@@ -295,7 +296,7 @@ export function StudioOnboardingClient({variant="ghost"size="sm"className="absolute top-4 right-4 text-xs text-muted-foreground"- onClick={() => signOut({ fetchOptions: { onSuccess: () => router.push("/sign-in") } })}+ onClick={async () => { await clearAllCache(); signOut({ fetchOptions: { onSuccess: () => router.push("/sign-in") } }); }}><LogOut className="size-3 mr-1.5" />Sign out@@ -363,7 +364,7 @@ export function StudioOnboardingClient({variant="ghost"size="sm"className="absolute top-4 right-4 text-xs text-muted-foreground"- onClick={() => signOut({ fetchOptions: { onSuccess: () => router.push("/sign-in") } })}+ onClick={async () => { await clearAllCache(); signOut({ fetchOptions: { onSuccess: () => router.push("/sign-in") } }); }}><LogOut className="size-3 mr-1.5" />Sign outdiff --git a/src/web/src/app/(app)/workspaces/client.tsx b/src/web/src/app/(app)/workspaces/client.tsxindex 26ba13612..42b67e5bb 100644--- a/src/web/src/app/(app)/workspaces/client.tsx+++ b/src/web/src/app/(app)/workspaces/client.tsx@@ -7,6 +7,7 @@ import { GradientBackground } from "@/components/gradient-background"import { Logo } from "@/components/logo"import { Plus, ArrowRight, LogOut } from "lucide-react"import { signOut } from "@/lib/auth-client"+import { clearAllCache } from "@/lib/chat-cache"interface WorkspaceItem {id: string@@ -30,6 +31,7 @@ export function WorkspaceListClient({size="sm"className="absolute top-4 right-4 text-muted-foreground"onClick={async () => {+ await clearAllCache()await signOut()router.push("/sign-in")}}diff --git a/src/web/src/app/api/daemon/tasks/poll/route.test.ts b/src/web/src/app/api/daemon/tasks/poll/route.test.tsindex b2fd7634b..534fe8d62 100644--- a/src/web/src/app/api/daemon/tasks/poll/route.test.ts+++ b/src/web/src/app/api/daemon/tasks/poll/route.test.ts@@ -21,9 +21,11 @@ const mockListScheduledMeetings = vi.fn();const mockClaimMeetingSessions = vi.fn();const mockGetAllEmailAccountsForWorkspace = vi.fn();const mockGetAllColleaguesForWorkspace = vi.fn();+const mockInvalidate = vi.fn().mockResolvedValue(undefined);+const mockKvPut = vi.fn().mockResolvedValue(undefined);vi.mock("@opennextjs/cloudflare", () => ({- getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),+ getCloudflareContext: vi.fn(() => ({ env: { DB: {}, CACHE_KV: { put: (...args: unknown[]) => mockKvPut(...args), get: vi.fn().mockResolvedValue(null), delete: vi.fn().mockResolvedValue(undefined) } } })),}));vi.mock("@/lib/db", () => ({@@ -114,6 +116,26 @@ vi.mock("@/lib/logger", () => ({log: { warn: vi.fn(), info: vi.fn(), error: vi.fn(), debug: vi.fn() },}));+vi.mock("@/lib/cache", () => ({+ cached: vi.fn((_key: string, _ttl: number, fn: () => Promise<any>) => fn()),+ cacheKeys: {+ machineToken: (token: string) => `mt:${token.slice(0, 20)}`,+ runtimeIds: (wsId: string, daemonId: string) => `rt:${wsId}:${daemonId}`,+ agent: (wsId: string, agentId: string) => `ag:${wsId}:${agentId}`,+ heartbeat: (wsId: string, daemonId: string) => `hb:${wsId}:${daemonId}`,+ user: (userId: string) => `usr:${userId}`,+ allAgents: (wsId: string) => `agents:${wsId}`,+ allEmailAccounts: (wsId: string) => `ea:${wsId}`,+ allColleagues: (wsId: string) => `col:${wsId}`,+ allRuntimes: (wsId: string) => `runtimes:${wsId}`,+ member: (wsId: string, userId: string) => `mem:${wsId}:${userId}`,+ allHandles: (wsId: string) => `handles:${wsId}`,+ allMembers: (wsId: string) => `members:${wsId}`,+ },+ throttled: vi.fn((_key: string, _interval: number, fn: () => Promise<void>) => fn().then(() => true)),+ invalidate: (...args: unknown[]) => mockInvalidate(...args),+}));+vi.mock("@/lib/api/responses", () => ({taskToResponse: (t: any) => ({id: t.id,@@ -814,4 +836,57 @@ describe("POST /api/daemon/tasks/poll", () => {expect(body.tasks).toEqual([]);expect(body.pending_update).toBeUndefined();});++ // --- Heartbeat cache invalidation ---++ it("invalidates allRuntimes cache on every poll heartbeat", async () => {+ mockUpsertMachine.mockResolvedValue({});+ mockGetRuntimeIdsByDaemon.mockResolvedValue(["r1"]);+ mockSweepStaleState.mockResolvedValue(undefined);+ mockBroadcastToUser.mockResolvedValue(undefined);+ mockClaimTasksForRuntimes.mockResolvedValue([]);++ await POST(postReq({ daemon_id: "d1" }));++ expect(mockInvalidate).toHaveBeenCalledWith("runtimes:w1");+ });++ it("writes KV heartbeat with 120s TTL", async () => {+ mockUpsertMachine.mockResolvedValue({});+ mockGetRuntimeIdsByDaemon.mockResolvedValue(["r1"]);+ mockSweepStaleState.mockResolvedValue(undefined);+ mockBroadcastToUser.mockResolvedValue(undefined);+ mockClaimTasksForRuntimes.mockResolvedValue([]);++ await POST(postReq({ daemon_id: "d1" }));++ expect(mockKvPut).toHaveBeenCalledWith(+ "hb:w1:d1",+ expect.any(String),+ { expirationTtl: 120 },+ );+ });++ it("poll does not crash when invalidate throws", async () => {+ mockInvalidate.mockRejectedValue(new Error("KV delete failed"));+ mockUpsertMachine.mockResolvedValue({});+ mockGetRuntimeIdsByDaemon.mockResolvedValue(["r1"]);+ mockSweepStaleState.mockResolvedValue(undefined);+ mockBroadcastToUser.mockResolvedValue(undefined);+ mockClaimTasksForRuntimes.mockResolvedValue([]);++ const res = await POST(postReq({ daemon_id: "d1" }));+ const body = await res.json();++ expect(res.status).toBe(200);+ expect(body.tasks).toEqual([]);+ });++ it("does not invalidate cache when daemon has no runtimes (evicted early)", async () => {+ mockGetRuntimeIdsByDaemon.mockResolvedValue([]);++ await POST(postReq({ daemon_id: "d1" }));++ expect(mockInvalidate).not.toHaveBeenCalled();+ });});diff --git a/src/web/src/app/api/daemon/tasks/poll/route.ts b/src/web/src/app/api/daemon/tasks/poll/route.tsindex 41aaa4253..eab59f592 100644--- a/src/web/src/app/api/daemon/tasks/poll/route.ts+++ b/src/web/src/app/api/daemon/tasks/poll/route.ts@@ -14,7 +14,7 @@ import { log } from "@/lib/logger";export const POST = withAuth(async (req: NextRequest, ctx) => {const { env } = getCloudflareContext();const db = getDb((env as Env).DB);- const { cached, cacheKeys, throttled } = await import("@/lib/cache");+ const { cached, cacheKeys, throttled, invalidate } = await import("@/lib/cache");const [body, err] = await parseBody(req, PollRequestSchema);if (err) return err;@@ -43,8 +43,9 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {kv.put(cacheKeys.heartbeat(ctx.workspaceId, body.daemon_id),new Date().toISOString(),- { expirationTtl: 60 },+ { expirationTtl: 120 },).catch(() => {});+ invalidate(cacheKeys.allRuntimes(ctx.workspaceId)).catch(() => {});}try {await throttled(diff --git a/src/web/src/components/agent-chat/agent-chat-view.tsx b/src/web/src/components/agent-chat/agent-chat-view.tsxindex 5de4cc626..76030d199 100644--- a/src/web/src/components/agent-chat/agent-chat-view.tsx+++ b/src/web/src/components/agent-chat/agent-chat-view.tsx@@ -32,6 +32,7 @@ import {flagMessage as apiFlagMessage,unflagMessage as apiUnflagMessage,} from "@/lib/api";+import { appendCachedMessage, mergeCachedMessages } from "@/lib/chat-cache";import type { PreviousConversation, TraceTask } from "@/lib/api";import type { Artifact, Conversation, Issue, IssueComment, Message, TaskApi as Task, TaskMessage, WsMessage } from "@alook/shared";import { useAgentContext } from "@/contexts/agent-context";@@ -44,6 +45,7 @@ import { Skeleton } from "@/components/ui/skeleton";import { Tooltip, TooltipTrigger, TooltipContent } from "@/components/ui/tooltip";import { ArrowUp, BedDouble, Box, FileText, Loader2, Mail, MessageSquareQuote, Mic, Paperclip, Square, X } from "lucide-react";import { useSpeechRecognition } from "@/hooks/use-speech-recognition";+import { useCachedMessages } from "@/hooks/use-cached-messages";import { useMentionPopup } from "@/hooks/use-mention-popup";import { MentionPopup } from "@/components/agent-chat/mention-popup";import { highlightMentions } from "@/lib/highlight-mentions";@@ -371,6 +373,12 @@ export function AgentChatView({const { increment: flagIncrement, decrement: flagDecrement, refresh: flagRefresh } = useFlagCount();+ const { cachedMessages, isFromCache, writeToCache } = useCachedMessages(targetConvId ?? null, workspaceId);+ const cachedMessagesRef = useRef(cachedMessages);+ const isFromCacheRef = useRef(isFromCache);+ const writeToCacheRef = useRef(writeToCache);+ useEffect(() => { cachedMessagesRef.current = cachedMessages; isFromCacheRef.current = isFromCache; writeToCacheRef.current = writeToCache; }, [cachedMessages, isFromCache, writeToCache]);+useEffect(() => {setChannelAgentId(agentId);}, [agentId, setChannelAgentId]);@@ -476,9 +484,11 @@ export function AgentChatView({pollRef.current = null;pollTaskIdRef.current = null;let ignore = false;+ const cached = cachedMessagesRef.current;+ const hasCacheHit = isFromCacheRef.current && cached && cached.length > 0;queueMicrotask(() => {if (ignore) return;- setLoading(true);+ setLoading(!hasCacheHit);initialScrollDone.current = false;setActiveTask(null);setTaskMessages([]);@@ -490,6 +500,9 @@ export function AgentChatView({setHasMoreConversations(false);oldestConversationCursorRef.current = null;setInput(localStorage.getItem(`chat-draft:${agentId}:${targetConvId ?? 'default'}`) ?? "");+ if (hasCacheHit) {+ setMessages(cached!);+ }});async function load() {try {@@ -503,10 +516,11 @@ export function AgentChatView({]);if (ignore) return;setConversation(conv);- setMessages(msgsResult.messages);+ setMessages((prev) => mergeMessages(prev, msgsResult.messages));setHasMore(msgsResult.has_more);setArtifacts(arts);setBufferedMessages(buffered);+ writeToCacheRef.current(msgsResult.messages, msgsResult.has_more).catch(() => {});const taskIds = [...new Set(msgsResult.messages.filter((m) => m.role === "assistant" && m.task_id).map((m) => m.task_id!))];if (taskIds.length > 0) {getTaskStepCounts(taskIds, workspaceId)@@ -534,11 +548,12 @@ export function AgentChatView({const data = await chatInit(agentId, workspaceId, activeChannel);if (ignore) return;setConversation(data.conversation);- setMessages(data.messages);+ setMessages((prev) => prev.length > 0 ? mergeMessages(prev, data.messages) : data.messages);setHasMore(data.has_more_messages);setArtifacts(data.artifacts);setBufferedMessages(data.buffered_messages);setHasMoreConversations(data.has_more_conversations);+ writeToCacheRef.current(data.messages, data.has_more_messages).catch(() => {});listFlaggedMessageIds(workspaceId, data.conversation.id).then((r) => { if (!ignore) setFlaggedIds(new Set(r.message_ids)); }).catch(() => {});@@ -547,11 +562,12 @@ export function AgentChatView({const data = await chatInit(agentId, workspaceId, activeChannel);if (ignore) return;setConversation(data.conversation);- setMessages(data.messages);+ setMessages((prev) => prev.length > 0 ? mergeMessages(prev, data.messages) : data.messages);setHasMore(data.has_more_messages);setArtifacts(data.artifacts);setBufferedMessages(data.buffered_messages);setHasMoreConversations(data.has_more_conversations);+ writeToCacheRef.current(data.messages, data.has_more_messages).catch(() => {});listFlaggedMessageIds(workspaceId, data.conversation.id).then((r) => { if (!ignore) setFlaggedIds(new Set(r.message_ids)); }).catch(() => {});@@ -575,6 +591,7 @@ export function AgentChatView({}load();return () => { ignore = true; };+ // eslint-disable-next-line react-hooks/exhaustive-deps}, [agentId, workspaceId, targetConvId, scrollToTaskId, activeChannel, channelLoading]);const refreshInboxCountRef = useRef(refreshInboxCount);@@ -860,6 +877,13 @@ export function AgentChatView({}});+ if (allNewMessages.length > 0 && conversation) {+ const currentConvMessages = allNewMessages.filter((m) => m.conversation_id === conversation.id);+ if (currentConvMessages.length > 0) {+ mergeCachedMessages(conversation.id, currentConvMessages, lastHasMore, workspaceId).catch(() => {});+ }+ }+loadingMoreRef.current = false;flushSync(() => setLoadingMore(false));@@ -1074,6 +1098,7 @@ export function AgentChatView({}if (msg.type === "conversation.message" && msg.conversationId === conversation?.id) {setMessages((prev) => mergeMessages(prev, [msg.message]));+ appendCachedMessage(msg.conversationId, msg.message, workspaceId).catch(() => {});}if (msg.type === "artifact.uploaded" && msg.conversationId === conversation?.id) {setArtifacts((prev) => {@@ -1090,6 +1115,7 @@ export function AgentChatView({listMessages(msg.conversationId, workspaceId).then(({ messages: latest }) => setMessages((prev) => mergeMessages(prev, latest))).catch(() => { });+ appendCachedMessage(msg.conversationId, msg.message, workspaceId).catch(() => {});const task = msg.task as Task;activeTaskIdRef.current = task.id;setActiveTask(task);diff --git a/src/web/src/components/dashboard-navbar.tsx b/src/web/src/components/dashboard-navbar.tsxindex d26a91abc..f5df3e041 100644--- a/src/web/src/components/dashboard-navbar.tsx+++ b/src/web/src/components/dashboard-navbar.tsx@@ -23,6 +23,7 @@ import { Logo } from "@/components/logo";import { toast } from "sonner";import type { AgentRuntime as Runtime } from "@alook/shared";import { signOut } from "@/lib/auth-client";+import { clearAllCache } from "@/lib/chat-cache";import { cliCmd, daemonStartCmd } from "@/lib/utils";import { ProviderLogo } from "@/components/provider-logo";@@ -404,6 +405,7 @@ export function DashboardNavbar() {variant="ghost"size="sm"onClick={async () => {+ await clearAllCache();await signOut();}}>diff --git a/src/web/src/components/nav-user.tsx b/src/web/src/components/nav-user.tsxindex aabfbcb2f..c537728e5 100644--- a/src/web/src/components/nav-user.tsx+++ b/src/web/src/components/nav-user.tsx@@ -3,6 +3,7 @@import { useEffect, useState } from "react";import { useRouter } from "next/navigation";import { useSession, signOut } from "@/lib/auth-client";+import { clearAllCache } from "@/lib/chat-cache";import {DropdownMenu,DropdownMenuContent,@@ -70,6 +71,7 @@ export function NavUser() {<DropdownMenuGroup><DropdownMenuItemonClick={async () => {+ await clearAllCache();await signOut();router.push("/sign-in");}}diff --git a/src/web/src/hooks/__tests__/use-cached-messages.test.ts b/src/web/src/hooks/__tests__/use-cached-messages.test.tsnew file mode 100644index 000000000..57dc0ac5f--- /dev/null+++ b/src/web/src/hooks/__tests__/use-cached-messages.test.ts@@ -0,0 +1,84 @@+import { describe, it, expect, beforeEach } from "vitest";+import "fake-indexeddb/auto";+import type { Message } from "@alook/shared";+import {+ openCacheDB,+ clearAllCache,+ getCachedMessages,+ mergeCachedMessages,+} from "@/lib/chat-cache";++const WORKSPACE_ID = "ws_test";++function makeMessage(overrides: Partial<Message> = {}): Message {+ return {+ id: `msg_${Math.random().toString(36).slice(2)}`,+ conversation_id: "conv_1",+ role: "user",+ content: "hello",+ task_id: null,+ attachment_ids: null,+ created_at: new Date().toISOString(),+ ...overrides,+ };+}++beforeEach(async () => {+ await clearAllCache();+ openCacheDB(WORKSPACE_ID);+});++describe("use-cached-messages (functional tests)", () => {+ it("getCachedMessages returns cached messages immediately after write", async () => {+ const msgs = [+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),+ ];+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).not.toBeNull();+ expect(cached).toHaveLength(2);+ expect(cached![0].id).toBe("m1");+ expect(cached![1].id).toBe("m2");+ });++ it("returns null when no cache exists", async () => {+ const cached = await getCachedMessages("conv_nonexistent", WORKSPACE_ID);+ expect(cached).toBeNull();+ });++ it("writeToCache (mergeCachedMessages) persists messages correctly", async () => {+ const msgs = [+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),+ ];+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(1);+ expect(cached![0].id).toBe("m1");+ });++ it("conversation switch loads correct cache", async () => {+ await mergeCachedMessages(+ "conv_1",+ [makeMessage({ id: "m1", conversation_id: "conv_1" })],+ false,+ WORKSPACE_ID+ );+ await mergeCachedMessages(+ "conv_2",+ [makeMessage({ id: "m2", conversation_id: "conv_2" })],+ false,+ WORKSPACE_ID+ );++ const cached1 = await getCachedMessages("conv_1", WORKSPACE_ID);+ const cached2 = await getCachedMessages("conv_2", WORKSPACE_ID);++ expect(cached1).toHaveLength(1);+ expect(cached1![0].id).toBe("m1");+ expect(cached2).toHaveLength(1);+ expect(cached2![0].id).toBe("m2");+ });+});diff --git a/src/web/src/hooks/use-cached-messages.ts b/src/web/src/hooks/use-cached-messages.tsnew file mode 100644index 000000000..fd993f791--- /dev/null+++ b/src/web/src/hooks/use-cached-messages.ts@@ -0,0 +1,55 @@+"use client";++import { useState, useEffect, useCallback, useRef } from "react";+import type { Message } from "@alook/shared";+import { getCachedMessages, mergeCachedMessages, openCacheDB } from "@/lib/chat-cache";++interface UseCachedMessagesResult {+ cachedMessages: Message[] | null;+ isFromCache: boolean;+ writeToCache: (messages: Message[], hasMore: boolean) => Promise<void>;+}++export function useCachedMessages(+ conversationId: string | null,+ workspaceId: string | null+): UseCachedMessagesResult {+ const [cachedMessages, setCachedMessages] = useState<Message[] | null>(null);+ const [isFromCache, setIsFromCache] = useState(false);+ const conversationIdRef = useRef(conversationId);++ useEffect(() => {+ conversationIdRef.current = conversationId;+ if (!conversationId || !workspaceId) {+ setCachedMessages(null);+ setIsFromCache(false);+ return;+ }++ openCacheDB(workspaceId);++ let cancelled = false;+ getCachedMessages(conversationId, workspaceId).then((messages) => {+ if (cancelled || conversationIdRef.current !== conversationId) return;+ if (messages && messages.length > 0) {+ setCachedMessages(messages);+ setIsFromCache(true);+ } else {+ setCachedMessages(null);+ setIsFromCache(false);+ }+ });++ return () => { cancelled = true; };+ }, [conversationId, workspaceId]);++ const writeToCache = useCallback(+ async (messages: Message[], hasMore: boolean) => {+ if (!conversationIdRef.current || !workspaceId) return;+ await mergeCachedMessages(conversationIdRef.current, messages, hasMore, workspaceId);+ },+ [workspaceId]+ );++ return { cachedMessages, isFromCache, writeToCache };+}diff --git a/src/web/src/lib/chat-cache.test.ts b/src/web/src/lib/chat-cache.test.tsnew file mode 100644index 000000000..5b52672e1--- /dev/null+++ b/src/web/src/lib/chat-cache.test.ts@@ -0,0 +1,270 @@+import { describe, it, expect, beforeEach } from "vitest";+import "fake-indexeddb/auto";+import type { Message } from "@alook/shared";+import {+ openCacheDB,+ getCachedMessages,+ mergeCachedMessages,+ appendCachedMessage,+ removeCachedMessage,+ getCacheMeta,+ invalidateCache,+ evictLRU,+ clearAllCache,+} from "./chat-cache";++const WORKSPACE_ID = "ws_test";++function makeMessage(overrides: Partial<Message> = {}): Message {+ return {+ id: `msg_${Math.random().toString(36).slice(2)}`,+ conversation_id: "conv_1",+ role: "user",+ content: "hello",+ task_id: null,+ attachment_ids: null,+ created_at: new Date().toISOString(),+ ...overrides,+ };+}++beforeEach(async () => {+ await clearAllCache();+ openCacheDB(WORKSPACE_ID);+});++describe("chat-cache", () => {+ describe("openCacheDB", () => {+ it("creates DB with correct schema", async () => {+ const p = openCacheDB(WORKSPACE_ID);+ expect(p).not.toBeNull();+ const db = await p!;+ expect(db.objectStoreNames.contains("messages")).toBe(true);+ expect(db.objectStoreNames.contains("cache_meta")).toBe(true);+ });+ });++ describe("mergeCachedMessages", () => {+ it("writes messages and updates meta", async () => {+ const msgs = [+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),+ ];++ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(2);+ expect(cached![0].id).toBe("m1");+ expect(cached![1].id).toBe("m2");++ const meta = await getCacheMeta("conv_1", WORKSPACE_ID);+ expect(meta).not.toBeNull();+ expect(meta!.messageCount).toBeGreaterThanOrEqual(2);+ expect(meta!.hasMore).toBe(false);+ });++ it("merges without overwriting older messages", async () => {+ const older = [+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),+ ];+ await mergeCachedMessages("conv_1", older, true, WORKSPACE_ID);++ const newer = [+ makeMessage({ id: "m3", conversation_id: "conv_1", created_at: "2024-01-01T00:02:00Z" }),+ ];+ await mergeCachedMessages("conv_1", newer, false, WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(3);+ expect(cached!.map((m) => m.id)).toEqual(["m1", "m2", "m3"]);+ });++ it("filters out buffered messages", async () => {+ const msgs = [+ makeMessage({ id: "m1", conversation_id: "conv_1", status: "active" }),+ makeMessage({ id: "m2", conversation_id: "conv_1", status: "buffered" }),+ ];++ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(1);+ expect(cached![0].id).toBe("m1");+ });++ it("filters out temp- messages", async () => {+ const msgs = [+ makeMessage({ id: "m1", conversation_id: "conv_1" }),+ makeMessage({ id: "temp-123", conversation_id: "conv_1" }),+ ];++ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(1);+ expect(cached![0].id).toBe("m1");+ });+ });++ describe("getCachedMessages", () => {+ it("returns sorted messages for a conversation", async () => {+ const msgs = [+ makeMessage({ id: "m2", conversation_id: "conv_1", created_at: "2024-01-01T00:01:00Z" }),+ makeMessage({ id: "m1", conversation_id: "conv_1", created_at: "2024-01-01T00:00:00Z" }),+ ];+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached![0].id).toBe("m1");+ expect(cached![1].id).toBe("m2");+ });++ it("returns null for unknown conversation", async () => {+ const cached = await getCachedMessages("nonexistent", WORKSPACE_ID);+ expect(cached).toBeNull();+ });++ it("excludes buffered messages on read", async () => {+ const db = await openCacheDB(WORKSPACE_ID)!;+ await db.put("messages", makeMessage({ id: "m1", conversation_id: "conv_1", status: "buffered" }));+ await db.put("messages", makeMessage({ id: "m2", conversation_id: "conv_1", status: "active" }));+ await db.put("cache_meta", {+ conversation_id: "conv_1",+ lastFetchedAt: Date.now(),+ lastAccessedAt: Date.now(),+ messageCount: 2,+ newestMessageId: "m2",+ hasMore: false,+ });++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(1);+ expect(cached![0].id).toBe("m2");+ });+ });++ describe("appendCachedMessage", () => {+ it("adds single message without overwriting existing", async () => {+ const initial = [makeMessage({ id: "m1", conversation_id: "conv_1" })];+ await mergeCachedMessages("conv_1", initial, false, WORKSPACE_ID);++ await appendCachedMessage("conv_1", makeMessage({ id: "m2", conversation_id: "conv_1" }), WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(2);+ });++ it("skips buffered messages", async () => {+ const initial = [makeMessage({ id: "m1", conversation_id: "conv_1" })];+ await mergeCachedMessages("conv_1", initial, false, WORKSPACE_ID);++ await appendCachedMessage("conv_1", makeMessage({ id: "m2", conversation_id: "conv_1", status: "buffered" }), WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(1);+ });++ it("skips temp- messages", async () => {+ const initial = [makeMessage({ id: "m1", conversation_id: "conv_1" })];+ await mergeCachedMessages("conv_1", initial, false, WORKSPACE_ID);++ await appendCachedMessage("conv_1", makeMessage({ id: "temp-abc", conversation_id: "conv_1" }), WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(1);+ });+ });++ describe("removeCachedMessage", () => {+ it("removes a single message by ID", async () => {+ const msgs = [+ makeMessage({ id: "m1", conversation_id: "conv_1" }),+ makeMessage({ id: "m2", conversation_id: "conv_1" }),+ ];+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ await removeCachedMessage("conv_1", "m1", WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toHaveLength(1);+ expect(cached![0].id).toBe("m2");+ });+ });++ describe("invalidateCache", () => {+ it("removes all data for a conversation", async () => {+ const msgs = [+ makeMessage({ id: "m1", conversation_id: "conv_1" }),+ makeMessage({ id: "m2", conversation_id: "conv_1" }),+ ];+ await mergeCachedMessages("conv_1", msgs, false, WORKSPACE_ID);++ await invalidateCache("conv_1", WORKSPACE_ID);++ const cached = await getCachedMessages("conv_1", WORKSPACE_ID);+ expect(cached).toBeNull();+ const meta = await getCacheMeta("conv_1", WORKSPACE_ID);+ expect(meta).toBeNull();+ });+ });++ describe("evictLRU", () => {+ it("keeps only the N most recently accessed conversations", async () => {+ const db = await openCacheDB(WORKSPACE_ID)!;++ // Write messages and meta directly to control lastAccessedAt precisely+ for (let i = 0; i < 5; i++) {+ await db.put("messages", makeMessage({ id: `m_${i}`, conversation_id: `conv_${i}`, created_at: `2024-01-0${i + 1}T00:00:00Z` }));+ await db.put("cache_meta", {+ conversation_id: `conv_${i}`,+ lastFetchedAt: Date.now(),+ lastAccessedAt: i * 1000,+ messageCount: 1,+ newestMessageId: `m_${i}`,+ hasMore: false,+ });+ }++ await evictLRU(3);++ // Only the 3 most recently accessed should remain (conv_2, conv_3, conv_4)+ const meta0 = await getCacheMeta("conv_0", WORKSPACE_ID);+ const meta1 = await getCacheMeta("conv_1", WORKSPACE_ID);+ const meta2 = await getCacheMeta("conv_2", WORKSPACE_ID);+ const meta3 = await getCacheMeta("conv_3", WORKSPACE_ID);+ const meta4 = await getCacheMeta("conv_4", WORKSPACE_ID);++ expect(meta0).toBeNull();+ expect(meta1).toBeNull();+ expect(meta2).not.toBeNull();+ expect(meta3).not.toBeNull();+ expect(meta4).not.toBeNull();+ });+ });++ describe("clearAllCache", () => {+ it("removes everything", async () => {+ await mergeCachedMessages(+ "conv_1",+ [makeMessage({ id: "m1", conversation_id: "conv_1" })],+ false,+ WORKSPACE_ID+ );+ await mergeCachedMessages(+ "conv_2",+ [makeMessage({ id: "m2", conversation_id: "conv_2" })],+ false,+ WORKSPACE_ID+ );++ await clearAllCache();++ const cached1 = await getCachedMessages("conv_1", WORKSPACE_ID);+ const cached2 = await getCachedMessages("conv_2", WORKSPACE_ID);+ expect(cached1).toBeNull();+ expect(cached2).toBeNull();+ });+ });+});diff --git a/src/web/src/lib/chat-cache.ts b/src/web/src/lib/chat-cache.tsnew file mode 100644index 000000000..7ac43edcb--- /dev/null+++ b/src/web/src/lib/chat-cache.ts@@ -0,0 +1,283 @@+import { openDB, type IDBPDatabase } from "idb";+import type { Message } from "@alook/shared";++export interface CacheMeta {+ conversation_id: string;+ lastFetchedAt: number;+ lastAccessedAt: number;+ messageCount: number;+ newestMessageId: string | null;+ hasMore: boolean;+}++interface ChatCacheDB {+ messages: {+ key: [string, string];+ value: Message;+ indexes: {+ "by-conversation": string;+ "by-created": [string, string];+ };+ };+ cache_meta: {+ key: string;+ value: CacheMeta;+ };+}++const DB_VERSION = 1;+const MAX_CONVERSATIONS = 50;++let dbPromise: Promise<IDBPDatabase<ChatCacheDB>> | null = null;+let currentWorkspaceId: string | null = null;++export function openCacheDB(workspaceId: string): Promise<IDBPDatabase<ChatCacheDB>> | null {+ if (typeof indexedDB === "undefined") return null;++ if (dbPromise && currentWorkspaceId === workspaceId) return dbPromise;++ currentWorkspaceId = workspaceId;+ dbPromise = openDB<ChatCacheDB>(`alook-chat-cache-${workspaceId}`, DB_VERSION, {+ upgrade(db) {+ const msgStore = db.createObjectStore("messages", {+ keyPath: ["conversation_id", "id"],+ });+ msgStore.createIndex("by-conversation", "conversation_id", { unique: false });+ msgStore.createIndex("by-created", ["conversation_id", "created_at"], { unique: false });++ db.createObjectStore("cache_meta", { keyPath: "conversation_id" });+ },+ });++ return dbPromise;+}++function getDB(workspaceId?: string): Promise<IDBPDatabase<ChatCacheDB>> | null {+ if (workspaceId) return openCacheDB(workspaceId);+ return dbPromise;+}++export async function getCachedMessages(conversationId: string, workspaceId?: string): Promise<Message[] | null> {+ const p = getDB(workspaceId);+ if (!p) return null;++ try {+ const db = await p;+ const messages = await db.getAllFromIndex("messages", "by-conversation", conversationId);+ if (messages.length === 0) return null;++ const filtered = messages.filter(+ (m) => m.status !== "buffered" && !m.id.startsWith("temp-")+ );++ filtered.sort((a, b) => {+ const cmp = a.created_at.localeCompare(b.created_at);+ if (cmp !== 0) return cmp;+ return a.id.localeCompare(b.id);+ });++ // Update lastAccessedAt+ const meta = await db.get("cache_meta", conversationId);+ if (meta) {+ await db.put("cache_meta", { ...meta, lastAccessedAt: Date.now() });+ }++ return filtered;+ } catch {+ return null;+ }+}++export async function mergeCachedMessages(+ conversationId: string,+ messages: Message[],+ hasMore: boolean,+ workspaceId?: string+): Promise<void> {+ const p = getDB(workspaceId);+ if (!p) return;++ try {+ const db = await p;++ const validMessages = messages.filter(+ (m) => m.status !== "buffered" && !m.id.startsWith("temp-")+ );+ if (validMessages.length === 0) return;++ const tx = db.transaction(["messages", "cache_meta"], "readwrite");+ const msgStore = tx.objectStore("messages");+ const metaStore = tx.objectStore("cache_meta");++ for (const msg of validMessages) {+ await msgStore.put(msg);+ }++ const allKeys = await msgStore.index("by-conversation").getAllKeys(conversationId);++ const now = Date.now();+ const newest = validMessages.reduce((a, b) =>+ a.created_at > b.created_at ? a : b+ );++ const meta: CacheMeta = {+ conversation_id: conversationId,+ lastFetchedAt: now,+ lastAccessedAt: now,+ messageCount: allKeys.length,+ newestMessageId: newest.id,+ hasMore,+ };+ await metaStore.put(meta);++ await tx.done;++ evictLRU().catch(() => {});+ } catch {+ // Graceful degradation+ }+}++export async function appendCachedMessage(+ conversationId: string,+ message: Message,+ workspaceId?: string+): Promise<void> {+ const p = getDB(workspaceId);+ if (!p) return;++ if (message.status === "buffered" || message.id.startsWith("temp-")) return;++ try {+ const db = await p;+ const existing = await db.get("messages", [conversationId, message.id]);+ await db.put("messages", message);++ const meta = await db.get("cache_meta", conversationId);+ if (meta) {+ await db.put("cache_meta", {+ ...meta,+ lastAccessedAt: Date.now(),+ messageCount: existing ? meta.messageCount : meta.messageCount + 1,+ newestMessageId: message.id,+ });+ }+ } catch {+ // Graceful degradation+ }+}++export async function removeCachedMessage(+ conversationId: string,+ messageId: string,+ workspaceId?: string+): Promise<void> {+ const p = getDB(workspaceId);+ if (!p) return;++ try {+ const db = await p;+ await db.delete("messages", [conversationId, messageId]);++ const meta = await db.get("cache_meta", conversationId);+ if (meta) {+ await db.put("cache_meta", {+ ...meta,+ messageCount: Math.max(0, meta.messageCount - 1),+ });+ }+ } catch {+ // Graceful degradation+ }+}++export async function getCacheMeta(conversationId: string, workspaceId?: string): Promise<CacheMeta | null> {+ const p = getDB(workspaceId);+ if (!p) return null;++ try {+ const db = await p;+ return (await db.get("cache_meta", conversationId)) ?? null;+ } catch {+ return null;+ }+}++export async function invalidateCache(conversationId: string, workspaceId?: string): Promise<void> {+ const p = getDB(workspaceId);+ if (!p) return;++ try {+ const db = await p;+ const tx = db.transaction(["messages", "cache_meta"], "readwrite");+ const msgStore = tx.objectStore("messages");+ const metaStore = tx.objectStore("cache_meta");++ const keys = await msgStore.index("by-conversation").getAllKeys(conversationId);+ for (const key of keys) {+ await msgStore.delete(key);+ }+ await metaStore.delete(conversationId);++ await tx.done;+ } catch {+ // Graceful degradation+ }+}++export async function evictLRU(maxConversations = MAX_CONVERSATIONS): Promise<void> {+ const p = getDB();+ if (!p) return;++ try {+ const db = await p;+ const allMeta = await db.getAll("cache_meta");+ if (allMeta.length <= maxConversations) return;++ allMeta.sort((a, b) => a.lastAccessedAt - b.lastAccessedAt);+ const toEvict = allMeta.slice(0, allMeta.length - maxConversations);++ const tx = db.transaction(["messages", "cache_meta"], "readwrite");+ const msgStore = tx.objectStore("messages");+ const metaStore = tx.objectStore("cache_meta");++ for (const meta of toEvict) {+ const keys = await msgStore.index("by-conversation").getAllKeys(meta.conversation_id);+ for (const key of keys) {+ await msgStore.delete(key);+ }+ await metaStore.delete(meta.conversation_id);+ }++ await tx.done;+ } catch {+ // Graceful degradation+ }+}++export async function clearAllCache(): Promise<void> {+ if (typeof indexedDB === "undefined") return;++ try {+ if (dbPromise) {+ const db = await dbPromise;+ db.close();+ dbPromise = null;+ }+ if (currentWorkspaceId) {+ await deleteDB(`alook-chat-cache-${currentWorkspaceId}`);+ currentWorkspaceId = null;+ }+ } catch {+ // Graceful degradation+ }+}++async function deleteDB(name: string): Promise<void> {+ return new Promise((resolve, reject) => {+ const req = indexedDB.deleteDatabase(name);+ req.onsuccess = () => resolve();+ req.onerror = () => reject(req.error);+ req.onblocked = () => resolve();+ });+}