feat: persist settings and enrich conversation context

tests/web/conversations-route.test.ts

@@ -0,0 +1,180 @@
+import express from 'express';
+import type { AddressInfo } from 'node:net';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { WebContext } from '../../src/web/context.js';
+import { createConversationsRouter } from '../../src/web/routes/conversations.js';
+
+const servers: Array<ReturnType<express.Express['listen']>> = [];
+
+async function request(app: express.Express, path: string): Promise<Response> {
+  const server = app.listen(0);
+  servers.push(server);
+  await new Promise<void>((resolve) => server.once('listening', resolve));
+  const { port } = server.address() as AddressInfo;
+  return fetch(`http://127.0.0.1:${port}${path}`);
+}
+
+afterEach(async () => {
+  await Promise.all(servers.splice(0).map((server) => new Promise<void>((resolve) => server.close(() => resolve()))));
+});
+
+describe('conversations route', () => {
+  it('reports an unavailable chat service instead of presenting it as an empty inbox', async () => {
+    const context = {
+      logger: { error: vi.fn() },
+      services: {},
+    } as unknown as WebContext;
+    const app = express().use('/api', createConversationsRouter(context));
+
+    const response = await request(app, '/api/conversations');
+
+    expect(response.status).toBe(503);
+    expect(await response.json()).toEqual({ error: 'Chat service not initialized' });
+  });
+
+  it('reports a cache read failure instead of presenting it as an empty inbox', async () => {
+    const logger = { error: vi.fn() };
+    const context = {
+      logger,
+      services: {
+        chat: {
+          getCachedConversations: vi.fn().mockRejectedValue(new Error('cache unavailable')),
+        },
+      },
+    } as unknown as WebContext;
+    const app = express().use('/api', createConversationsRouter(context));
+
+    const response = await request(app, '/api/conversations');
+
+    expect(response.status).toBe(500);
+    expect(await response.json()).toEqual({ error: 'Failed to fetch conversations' });
+    expect(logger.error).toHaveBeenCalledWith('Failed to fetch conversations:', expect.any(Error));
+  });
+
+  it('marks conversations that have received images in the durable media index', async () => {
+    const conversation = {
+      username: 'alice',
+      roomName: 'alice',
+      roomId: 'room-alice',
+      lastMessageTime: 1_786_000_000_000,
+      lastMessageSnippet: '[Image]',
+      isFromUs: false,
+      unread: true,
+    };
+    const context = {
+      logger: { error: vi.fn() },
+      services: {
+        chat: { getCachedConversations: vi.fn().mockResolvedValue([conversation]) },
+        media: {
+          getMediaItems: vi.fn().mockResolvedValue([
+            {
+              id: 'image-one',
+              chatUsername: 'alice',
+              chatRoomId: 'room-alice',
+              sender: 'alice',
+              timestamp: 1_786_000_000_000,
+              originalUrl: 'mxc://reddit.com/image-one',
+              fileName: 'image-one.jpg',
+              relativePath: 'image-one.jpg',
+              createdAt: 1_786_000_000_100,
+            },
+          ]),
+        },
+      },
+    } as unknown as WebContext;
+    const app = express().use('/api', createConversationsRouter(context));
+
+    const legacyResponse = await request(app, '/api/conversations');
+    const response = await request(app, '/api/conversations?includeImageMetadata=true');
+
+    expect(legacyResponse.status).toBe(200);
+    expect(await legacyResponse.json()).toEqual([conversation]);
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual([{ ...conversation, hasReceivedImages: true }]);
+  });
+
+  it('serves conversation details without starting a delta sync', async () => {
+    const conversation = {
+      username: 'alice',
+      roomName: 'alice',
+      roomId: 'room-alice',
+      lastMessageTime: 1_786_000_000_000,
+      lastMessageSnippet: 'Hello',
+      isFromUs: false,
+      unread: false,
+      messages: [{
+        sender: 'alice',
+        text: 'Hello',
+        timestamp: 1_786_000_000_000,
+        isSelf: false,
+      }],
+    };
+    const refreshTopChats = vi.fn();
+    const loadConversationDetails = vi.fn();
+    const context = {
+      logger: { error: vi.fn(), warn: vi.fn() },
+      repos: {
+        messages: { getLatestByRecipient: vi.fn().mockReturnValue(undefined) },
+      },
+      services: {
+        chat: {
+          getSyncStatus: vi.fn().mockReturnValue({
+            syncing: false,
+            syncingKind: null,
+            progress: null,
+          }),
+          getCachedConversations: vi.fn().mockResolvedValue([conversation]),
+          refreshTopChats,
+          loadConversationDetails,
+          saveCacheExternal: vi.fn(),
+        },
+      },
+    } as unknown as WebContext;
+    const app = express().use('/api', createConversationsRouter(context));
+
+    const response = await request(app, '/api/conversations/room-alice');
+
+    expect(response.status).toBe(200);
+    expect((await response.json()).username).toBe('alice');
+    expect(refreshTopChats).not.toHaveBeenCalled();
+    expect(loadConversationDetails).not.toHaveBeenCalled();
+  });
+
+  it('attaches the exact room origin with its saved URL, title, and image', async () => {
+    const conversation = {
+      username: 'alice', roomName: 'alice', roomId: 'room-alice',
+      lastMessageTime: 10, lastMessageSnippet: 'Hello', isFromUs: true, unread: false,
+      messages: [{ sender: 'me', text: 'Hello', timestamp: 10, isSelf: true }],
+    };
+    const roomOrigin = {
+      id: 7, postId: 'post-exact', recipient: 'alice', subject: 'alice', message: 'Hello',
+      sentAt: 9, gotResponse: false, responseCheckedAt: null, strategyId: null,
+      chatRoomId: 'room-alice', subreddit: 'example', postTitle: 'Exact source post',
+      postUrl: 'https://www.reddit.com/r/example/comments/post-exact/exact_source_post/',
+      postImageUrl: 'https://i.redd.it/exact-source.jpg',
+    };
+    const latestRecipientOrigin = { ...roomOrigin, postId: 'wrong-latest-post', postTitle: 'Wrong post' };
+    const context = {
+      logger: { error: vi.fn(), warn: vi.fn() },
+      repos: { messages: {
+        getByChatRoomId: vi.fn().mockReturnValue(roomOrigin),
+        getLatestByRecipient: vi.fn().mockReturnValue(latestRecipientOrigin),
+      } },
+      services: { chat: {
+        getSyncStatus: vi.fn().mockReturnValue({ syncing: false, syncingKind: null, progress: null }),
+        getCachedConversations: vi.fn().mockResolvedValue([conversation]),
+        loadConversationDetails: vi.fn(), saveCacheExternal: vi.fn(),
+      } },
+    } as unknown as WebContext;
+    const app = express().use('/api', createConversationsRouter(context));
+
+    const response = await request(app, '/api/conversations/room-alice');
+
+    expect(response.status).toBe(200);
+    expect((await response.json()).triggeringPost).toEqual({
+      id: 'post-exact', subreddit: 'example', title: 'Exact source post',
+      url: roomOrigin.postUrl, imageUrl: roomOrigin.postImageUrl, sentAt: 9,
+    });
+    expect(context.repos.messages.getLatestByRecipient).not.toHaveBeenCalled();
+  });
+});

tests/web/media-route.test.ts

@@ -0,0 +1,66 @@
+import express from 'express';
+import type { AddressInfo } from 'node:net';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { WebContext } from '../../src/web/context.js';
+import { createMediaRouter } from '../../src/web/routes/media.js';
+
+const servers: Array<ReturnType<express.Express['listen']>> = [];
+
+async function request(app: express.Express, path: string): Promise<Response> {
+  const server = app.listen(0);
+  servers.push(server);
+  await new Promise<void>((resolve) => server.once('listening', resolve));
+  const { port } = server.address() as AddressInfo;
+  return fetch(`http://127.0.0.1:${port}${path}`);
+}
+
+afterEach(async () => {
+  await Promise.all(servers.splice(0).map((server) => new Promise<void>((resolve) => server.close(() => resolve()))));
+});
+
+describe('media route username presentation', () => {
+  it('upgrades historical t2 fields through the chat username map', async () => {
+    const context = {
+      logger: { error: vi.fn() },
+      services: {
+        media: { getMediaItems: vi.fn().mockResolvedValue([{
+          id: 'one', chatUsername: 't2_known', chatRoomId: 'room-one', sender: 't2_known',
+          timestamp: 1, originalUrl: 'mxc://one', fileName: 'one.jpg', relativePath: 'one.jpg', createdAt: 2,
+        }]) },
+        chat: {
+          getCachedConversations: vi.fn().mockResolvedValue([]),
+          resolveSenderDisplay: vi.fn((identity: string) => identity === 't2_known' ? 'alice' : identity),
+        },
+      },
+    } as unknown as WebContext;
+    const app = express().use('/api', createMediaRouter(context));
+
+    const response = await request(app, '/api/media');
+
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual([expect.objectContaining({ chatUsername: 'alice', sender: 'alice' })]);
+  });
+
+  it('uses a safe fallback when no username mapping exists', async () => {
+    const context = {
+      logger: { error: vi.fn() },
+      services: {
+        media: { getMediaItems: vi.fn().mockResolvedValue([{
+          id: 'one', chatUsername: 't2_missing', chatRoomId: 'room-one', sender: '@t2_missing:reddit.com',
+          timestamp: 1, originalUrl: 'mxc://one', fileName: 'one.jpg', relativePath: 'one.jpg', createdAt: 2,
+        }]) },
+        chat: {
+          getCachedConversations: vi.fn().mockResolvedValue([]),
+          resolveSenderDisplay: vi.fn((identity: string) => identity),
+        },
+      },
+    } as unknown as WebContext;
+    const app = express().use('/api', createMediaRouter(context));
+
+    const response = await request(app, '/api/media');
+    const body = await response.json();
+
+    expect(JSON.stringify(body)).not.toContain('t2_missing');
+    expect(body[0]).toMatchObject({ chatUsername: null, sender: 'Unknown Reddit user' });
+  });
+});

tests/web/reddit-identities.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { presentActivityItem, resolveRedditUsername } from '../../src/web/reddit-identities.js';
+
+const resolver = {
+  resolveSenderDisplay(identity: string) {
+    return identity.replace(/^@?t2_known(?::reddit\.com)?$/, 'alice');
+  },
+};
+
+describe('Reddit identity presentation', () => {
+  it('resolves internal ids and rejects unresolved ids', () => {
+    expect(resolveRedditUsername('@t2_known:reddit.com', resolver)).toBe('alice');
+    expect(resolveRedditUsername('t2_missing', resolver)).toBeNull();
+  });
+
+  it('upgrades both the activity recipient and its persisted message text', () => {
+    expect(presentActivityItem({
+      timestamp: 1,
+      type: 'response',
+      message: 'Reply from u/t2_known',
+      recipient: 't2_known',
+    }, resolver)).toEqual({
+      timestamp: 1,
+      type: 'response',
+      message: 'Reply from u/alice',
+      recipient: 'alice',
+    });
+  });
+
+  it('redacts unresolved ids instead of exposing them', () => {
+    const item = presentActivityItem({
+      timestamp: 1,
+      type: 'response',
+      message: 'Reply from @t2_missing:reddit.com',
+      recipient: 't2_missing',
+    }, resolver);
+
+    expect(item.message).toBe('Reply from Reddit user');
+    expect(item.recipient).toBeUndefined();
+  });
+});