Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

feat: add IndexedDB chat message cache for instant conversation display

Gus2f49186c44ee
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4f039e80c..bbd83200a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -246,6 +246,9 @@ importers:
gsap:
specifier: ^3.15.0
version: 3.15.0
+ idb:
+ specifier: ^8.0.3
+ version: 8.0.3
input-otp:
specifier: ^1.4.2
@@ -319,6 +322,9 @@ importers:
eslint-plugin-tailwind-canonical-classes:
specifier: ^1.3.3
+ fake-indexeddb:
+ specifier: ^6.2.5
+ version: 6.2.5
tailwindcss:
specifier: ^4
version: 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
+
@@ -12142,6 +12157,8 @@ snapshots:
dependencies:
safer-buffer: 2.1.2
+
diff --git a/src/web/package.json b/src/web/package.json
index 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.tsx
index 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 out
diff --git a/src/web/src/app/(app)/workspaces/client.tsx b/src/web/src/app/(app)/workspaces/client.tsx
index 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.ts
index 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.ts
index 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.tsx
index 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.tsx
index 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.tsx
index 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>
<DropdownMenuItem
onClick={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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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();
+ });
+}