| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318 |
- import test from 'node:test';
- import assert from 'node:assert/strict';
- import { createStore } from '../src/store.js';
- import { createChatMetadataCollector } from '../src/network-chat-metadata.js';
- import { classifyMessage } from '../src/message-signals.js';
- const tenant = '11111111-1111-4111-8111-111111111111';
- const self = '22222222-2222-4222-8222-222222222222';
- const other = '33333333-3333-4333-8333-333333333333';
- const accountId = `web-api:${tenant}:${self}`;
- const account2 = `web-api:${tenant}:${other}`;
- const chatId = '19:fictional-group@thread.v2';
- const base = (chat = chatId, host = 'teams.cloud.microsoft') => `https://${host}/api/chatsvc/apac/v1/users/ME/conversations/${encodeURIComponent(chat)}`;
- const scope = (chat = chatId, account = accountId) => ({ source: 'web-api', accountId: account, kind: 'chat', externalId: chat });
- const observation = (chat = chatId, account = accountId) => ({ accountId: account, chatId: chat,
- requestUrl: `${base(chat)}/messages?pageSize=200`, headers: { Authorization: 'Bearer private-token-marker', 'X-Ms-Client-Type': 'web' } });
- const messages = (chat = chatId) => ({ messages: [{ conversationid: chat, conversationLink: base(chat), content: 'Private message marker' }] });
- const details = (chat = chatId, topic = 'Fictional group', revision = '1788850000000') => ({ type: 'Conversation', id: chat, version: 17,
- properties: { secret: 'private-property-marker' }, threadProperties: { topic, threadType: 'chat', version: revision, secret: 'private-thread-marker' },
- lastMessage: { content: 'private-preview-marker' }, messages: 'private-messages-marker' });
- const publicResult = result => assert.doesNotMatch(JSON.stringify(result), /private-|Fictional|19:|web-api:|https:|Bearer/);
- test('observed meeting topics resolve existing messages by account without rewriting history or classifying them as direct chats', async () => {
- const store = createStore(':memory:');
- const meetingId = '19:meeting_ZmljdGlvbmFs@thread.v2';
- try {
- for (const account of [accountId, account2]) store.upsertRecord({ ...scope(meetingId, account), kind: 'message',
- externalId: 'meeting-message', parentId: meetingId, title: '聊天消息', text: 'Original meeting message', raw: { author: 'Fictional speaker' } });
- const messageScope = { ...scope(meetingId), kind: 'message', externalId: 'meeting-message' };
- const before = store.getRecordByIdentity(messageScope), versions = store.getRecord(before.id).versions;
- const body = details(meetingId, '<b>Fictional meeting & review</b>'); body.threadProperties.threadType = 'meeting';
- const collector = createChatMetadataCollector({ store, fetch: async () => Response.json(body) });
- assert.equal(collector.observe(observation(meetingId), messages(meetingId)), true);
- const result = await collector.runOnce(); publicResult(result);
- assert.equal(result.successful, 1); assert.equal(result.changed, 1); assert.deepEqual(result.errors, []);
- const chat = store.getRecordByIdentity(scope(meetingId));
- assert.equal(chat.title, 'Fictional meeting & review'); assert.equal(chat.raw.threadType, 'meeting');
- assert.equal(chat.raw.titleSource, 'conversation-details'); assert.doesNotMatch(JSON.stringify(chat), /private-/);
- assert.equal(store.getRecord(before.id).displayTitle, chat.title);
- assert.equal(store.listRecords({ kind: 'message', accountId, q: chat.title }).total, 1);
- assert.equal(store.listRecords({ kind: 'message', accountId: account2, q: chat.title }).total, 0);
- assert.deepEqual(store.getRecordByIdentity(messageScope), before);
- assert.deepEqual(store.getRecord(before.id).versions, versions);
- assert.equal(classifyMessage(before, chat).chatType, 'meeting');
- assert.equal(classifyMessage(before, chat).isDirect, false);
- } finally { store.close(); }
- });
- test('meeting details keep identity, topic and revision validation and preserve known names when a topic is omitted', async () => {
- const store = createStore(':memory:'); let at = 2000000000000;
- const meetingId = '19:meeting_c2Vjb25k@thread.v2';
- try {
- let body;
- const collector = createChatMetadataCollector({ store, now: () => at, fetch: async () => Response.json(body) });
- collector.observe(observation(meetingId), messages(meetingId));
- const fresh = () => { const value = details(meetingId, 'Current meeting'); value.threadProperties.threadType = 'meeting'; return value; };
- body = fresh(); assert.equal((await collector.runOnce()).changed, 1);
- for (const change of [v => { delete v.threadProperties.topic; }, v => { v.threadProperties.topic = null; },
- v => { v.threadProperties.topic = ''; }, v => { v.threadProperties.topic = 'Old name'; v.threadProperties.version = '1788840000000'; }]) {
- at += 30 * 60_000; body = fresh(); change(body);
- const result = await collector.runOnce(); assert.equal(result.successful, 1); assert.equal(result.changed, 0);
- assert.equal(store.getRecordByIdentity(scope(meetingId)).title, 'Current meeting');
- }
- for (const change of [v => { v.id = '19:meeting_d3Jvbmc@thread.v2'; }, v => { v.threadProperties.version = 'invalid'; },
- v => { v.threadProperties.topic = {}; }, v => { v.threadProperties.threadType = 'unknown'; }]) {
- at += 30 * 60_000; body = fresh(); change(body);
- const result = await collector.runOnce(); assert.equal(result.changed, 0); assert.equal(result.errors[0].code, 'invalid-metadata');
- assert.equal(store.getRecordByIdentity(scope(meetingId)).title, 'Current meeting');
- }
- } finally { store.close(); }
- });
- test('observed conversation detail names the account-scoped chat without copying previews or changing messages', async () => {
- const store = createStore(':memory:'); let calls = 0;
- try {
- store.upsertRecord({ ...scope(), kind: 'message', externalId: 'message-id', parentId: chatId, title: '聊天消息', text: 'unchanged', raw: {} });
- const message = store.getRecordByIdentity({ ...scope(), kind: 'message', externalId: 'message-id' });
- const collector = createChatMetadataCollector({ store, fetch: async (url, options) => {
- calls++; assert.equal(url, base()); assert.equal(options.method, 'GET'); assert.equal(options.redirect, 'manual');
- assert.equal(options.credentials, 'omit'); assert.equal(options.headers.Authorization, 'Bearer private-token-marker');
- assert.ok(options.signal instanceof AbortSignal); return Response.json(details());
- } });
- assert.equal(collector.observe(observation(), messages()), true);
- const result = await collector.runOnce(); publicResult(result);
- assert.equal(calls, 1); assert.equal(result.successful, 1); assert.equal(result.changed, 1);
- const chat = store.getRecordByIdentity(scope());
- assert.equal(chat.title, 'Fictional group'); assert.equal(chat.updatedAt, '2026-09-08T06:46:40.000Z');
- assert.deepEqual(chat.raw, { chatId, titleSource: 'conversation-details', threadType: 'chat', version: '1788850000000' });
- assert.doesNotMatch(JSON.stringify(chat), /private-/);
- const after = store.getRecordByIdentity({ ...scope(), kind: 'message', externalId: 'message-id' });
- assert.equal(after.hash, message.hash); assert.equal(after.title, '聊天消息');
- assert.equal(store.listRecords({ kind: 'message' }).items[0].displayTitle, 'Fictional group');
- assert.equal((await collector.runOnce()).requests, 0);
- } finally { store.close(); }
- });
- test('observations reject foreign origin, conversation mismatches, activity streams, and non-observed URLs before HTTP', async () => {
- const store = createStore(':memory:'); let calls = 0;
- try {
- const collector = createChatMetadataCollector({ store, fetch: async () => { calls++; throw new Error('must not fetch'); } });
- const invalidLinks = [base().replace('teams.cloud.microsoft', 'teams.microsoft.com'), base().replace('teams.cloud.microsoft', 'evil.example'),
- `${base()}?token=private-token`, `${base()}#private-token`, base().replace('https:', 'http:'),
- base().replace('https://', 'https://user:private-token@'), base().replace('/api/', ':8443/api/'), base().replace('/api/', ':443/api/'),
- base().replace('/apac/', '/emea/'), `${base()}/messages`, base('19:other-chat@thread.v2'),
- base().replace('/ME/', '/someone/'), base().replace('/api/', '/evil/'), base().replace('https://', 'https:\\')];
- for (const link of invalidLinks) assert.equal(collector.observe(observation(), { messages: [{ conversationid: chatId, conversationLink: link }] }), false);
- assert.equal(collector.observe(observation(), { messages: [...messages().messages, { conversationid: '19:other@thread.v2', conversationLink: base() }] }), false);
- assert.equal(collector.observe(observation(), { messages: [] }), false);
- assert.equal(collector.observe(observation('48:notifications'), messages('48:notifications')), false);
- assert.equal(collector.observe({ ...observation(), accountId: 'other-account' }, messages()), false);
- assert.equal(collector.observe({ ...observation(), headers: {} }, messages()), false);
- assert.equal(collector.observe({ ...observation(), headers: { Authorization: 'Bearer private-token\r\ninjected' } }, messages()), false);
- assert.equal(collector.observe({ ...observation(), requestUrl: `${base()}/messages#private-fragment` }, messages()), false);
- assert.equal((await collector.runOnce()).requests, 0); assert.equal(calls, 0); assert.equal(store.stats().total, 0);
- } finally { store.close(); }
- });
- test('both observed Teams hosts and unq private-chat identities are supported only within the original origin', async () => {
- const store = createStore(':memory:');
- try {
- const chat = `19:${self}_${other}@unq.gbl.spaces`;
- const collector = createChatMetadataCollector({ store, fetch: async () => Response.json(details(chat)) });
- assert.equal(collector.observe({ ...observation(chat), requestUrl: `${base(chat, 'teams.microsoft.com')}/messages` },
- { messages: [{ conversationid: chat, conversationLink: base(chat, 'teams.microsoft.com') }] }), true);
- assert.equal((await collector.runOnce()).changed, 1);
- } finally { store.close(); }
- });
- test('same chat IDs remain isolated across account records and persistent cache keys', async () => {
- const store = createStore(':memory:'); let calls = 0;
- try {
- const collector = createChatMetadataCollector({ store, fetch: async () => Response.json(details(chatId, ++calls === 1 ? 'First group' : 'Second group')) });
- collector.observe(observation(), messages()); collector.observe(observation(chatId, account2), messages());
- const result = await collector.runOnce(); assert.equal(result.requests, 2); assert.equal(result.changed, 2);
- assert.equal(store.getRecordByIdentity(scope()).title, 'First group');
- assert.equal(store.getRecordByIdentity(scope(chatId, account2)).title, 'Second group');
- assert.equal(store.readRows("SELECT key FROM state WHERE key LIKE 'web-api:chat-metadata:%'").length, 2);
- } finally { store.close(); }
- });
- test('zero budget performs no HTTP and a larger requested budget still sends at most three detail reads', async () => {
- const store = createStore(':memory:'); let calls = 0;
- try {
- const collector = createChatMetadataCollector({ store, fetch: async raw => {
- calls++; return Response.json(details(decodeURIComponent(new URL(raw).pathname.split('/').at(-1))));
- } });
- for (let index = 0; index < 5; index++) { const chat = `19:group-${index}@thread.v2`; collector.observe(observation(chat), messages(chat)); }
- assert.equal((await collector.runOnce({ maxRequests: 0 })).requests, 0);
- assert.equal((await collector.runOnce({ maxRequests: 100 })).requests, 3); assert.equal(calls, 3);
- assert.deepEqual(collector.coverage(), { discovered: 5, cached: 3, pending: 2, paused: 0, rateLimited: 0 });
- assert.equal((await collector.runOnce()).requests, 2); assert.equal(calls, 5);
- } finally { store.close(); }
- });
- test('success cache survives collector recreation and unchanged valid detail does not add a record version', async () => {
- const store = createStore(':memory:'); let at = 2000000000000, calls = 0;
- try {
- const make = () => createChatMetadataCollector({ store, now: () => at, fetch: async () => { calls++; return Response.json(details()); } });
- const first = make(); first.observe(observation(), messages()); await first.runOnce(); const versions = store.stats().versions;
- const next = make(); next.observe(observation(), messages()); assert.equal((await next.runOnce()).requests, 0);
- at += 30 * 60_000 - 1; assert.equal((await next.runOnce()).requests, 0);
- at++; assert.equal((await next.runOnce()).successful, 1); assert.equal(calls, 2); assert.equal(store.stats().versions, versions);
- } finally { store.close(); }
- });
- test('empty and older topics preserve known titles; newer details retain previously normalized member evidence', async () => {
- const store = createStore(':memory:'); let at = 2000000000000, body = details(chatId, '');
- try {
- store.upsertRecord({ ...scope(), title: 'Current title', text: '', updatedAt: '2026-09-08T06:46:40.000Z',
- raw: { version: 1788850000000, titleSource: 'explicit', isOneOnOne: false, members: [{ userId: other, displayName: 'Fictional person' }] } });
- const collector = createChatMetadataCollector({ store, now: () => at, fetch: async () => Response.json(body) });
- collector.observe(observation(), messages()); assert.equal((await collector.runOnce()).changed, 0);
- at += 30 * 60_000; body = details(chatId, 'Old title', '1788840000000'); assert.equal((await collector.runOnce()).changed, 0);
- assert.equal(store.getRecordByIdentity(scope()).title, 'Current title');
- at += 30 * 60_000; body = details(chatId, '<b>New & clean</b>', '1788860000000'); assert.equal((await collector.runOnce()).changed, 1);
- const chat = store.getRecordByIdentity(scope()); assert.equal(chat.title, 'New & clean'); assert.equal(chat.raw.isOneOnOne, false);
- assert.equal(chat.raw.members[0].userId, other); assert.equal(chat.raw.titleSource, 'conversation-details');
- } finally { store.close(); }
- });
- test('missing or null topics cache a valid unnamed response without inventing or erasing chat titles', async () => {
- const store = createStore(':memory:'); let at = 2000000000000, calls = 0;
- try {
- const knownChat = '19:known-group@thread.v2';
- store.upsertRecord({ ...scope(knownChat), title: 'Preserved title', text: '', raw: { titleSource: 'explicit' } });
- const original = store.getRecordByIdentity(scope(knownChat));
- const collector = createChatMetadataCollector({ store, now: () => at, fetch: async raw => {
- calls++;
- const id = decodeURIComponent(new URL(raw).pathname.split('/').at(-1)), body = details(id);
- if (id === chatId) delete body.threadProperties.topic;
- else body.threadProperties.topic = null;
- return Response.json(body);
- } });
- collector.observe(observation(), messages()); collector.observe(observation(knownChat), messages(knownChat));
- const result = await collector.runOnce();
- assert.equal(result.successful, 2); assert.equal(result.changed, 0); assert.deepEqual(result.errors, []);
- assert.equal(store.getRecordByIdentity(scope()), null);
- assert.equal(store.getRecordByIdentity(scope(knownChat)).hash, original.hash);
- assert.equal(store.getRecordByIdentity(scope(knownChat)).title, 'Preserved title');
- assert.equal((await collector.runOnce()).requests, 0);
- at += 30 * 60_000 - 1; assert.equal((await collector.runOnce()).requests, 0); assert.equal(calls, 2);
- at++; assert.equal((await collector.runOnce()).successful, 2); assert.equal(calls, 4); assert.equal(store.stats().versions, 1);
- } finally { store.close(); }
- });
- test('unrecognized or mismatched detail schemas never save names and retry only after the failure TTL', async () => {
- const variants = [value => { value.id = '19:other@thread.v2'; }, value => { value.type = 'Message'; },
- value => { value.version = '17'; }, value => { value.threadProperties = null; },
- value => { value.threadProperties.version = 'not-a-version'; }, value => { value.threadProperties.topic = {}; },
- value => { value.threadProperties.topic = 42; }, value => { value.threadProperties.topic = []; },
- value => { delete value.threadProperties.topic; value.id = '19:other@thread.v2'; },
- value => { value.threadProperties.topic = null; value.threadProperties.version = 'not-a-version'; },
- value => { value.threadProperties.threadType = 'unknown'; }];
- for (const modify of variants) {
- const store = createStore(':memory:'); let at = 2000000000000, calls = 0;
- try {
- const body = details(); modify(body);
- const collector = createChatMetadataCollector({ store, now: () => at, fetch: async () => { calls++; return Response.json(body); } });
- collector.observe(observation(), messages()); const result = await collector.runOnce(); publicResult(result);
- assert.equal(result.errors[0].status, 200); assert.equal(result.errors[0].code, 'invalid-metadata');
- assert.match(result.errors[0].reason, /校验/); assert.equal(store.stats().total, 0);
- assert.equal((await collector.runOnce()).requests, 0); at += 5 * 60_000; assert.equal((await collector.runOnce()).requests, 1); assert.equal(calls, 2);
- } finally { store.close(); }
- }
- });
- test('401 and 403 pause a detail plan even when its messages are observed again', async () => {
- for (const status of [401, 403]) {
- const store = createStore(':memory:'); let at = 2000000000000;
- try {
- const collector = createChatMetadataCollector({ store, now: () => at, fetch: async () => new Response('private-error-marker', { status }) });
- collector.observe(observation(), messages()); const result = await collector.runOnce(); assert.equal(result.paused, 1); publicResult(result);
- at += 60 * 60_000; collector.observe(observation(), messages()); assert.equal((await collector.runOnce()).requests, 0);
- const renewed = createChatMetadataCollector({ store, now: () => at, fetch: async () => Response.json(details()) });
- renewed.observe(observation(), messages()); assert.equal((await renewed.runOnce()).changed, 1);
- } finally { store.close(); }
- }
- });
- test('429 Retry-After persists an origin cooldown that defers other chats across recreation', async () => {
- const store = createStore(':memory:'); let at = 2000000000000, calls = 0;
- try {
- const make = response => createChatMetadataCollector({ store, now: () => at, fetch: async raw => { calls++; return response(raw); } });
- const first = make(() => new Response('', { status: 429, headers: { 'retry-after': '1200' } }));
- for (const chat of [chatId, '19:second@thread.v2']) first.observe(observation(chat), messages(chat));
- const result = await first.runOnce(); assert.equal(result.requests, 1); assert.equal(result.rateLimited, 2); publicResult(result);
- const next = make(raw => Response.json(details(decodeURIComponent(new URL(raw).pathname.split('/').at(-1)))));
- next.observe(observation('19:second@thread.v2'), messages('19:second@thread.v2'));
- at += 20 * 60_000 - 1; assert.equal((await next.runOnce()).requests, 0);
- at++; assert.equal((await next.runOnce()).successful, 1); assert.equal(calls, 2);
- } finally { store.close(); }
- });
- test('redirects, unexpected MIME, oversize streamed bodies and provider exceptions return only safe errors', async () => {
- const responses = [() => new Response('private-redirect', { status: 302, headers: { location: 'https://evil.example/private-target' } }),
- () => new Response('private-html', { headers: { 'content-type': 'text/html' } }),
- () => new Response('{}', { headers: { 'content-type': 'application/json', 'content-length': '2097153' } }),
- () => new Response('x'.repeat(2097153), { headers: { 'content-type': 'application/json' } }),
- () => { throw new Error('Bearer private-token-marker https://evil.example/private-secret'); }];
- for (const response of responses) {
- const store = createStore(':memory:'); let calls = 0;
- try {
- const collector = createChatMetadataCollector({ store, fetch: async () => { calls++; return response(); } });
- collector.observe(observation(), messages()); const result = await collector.runOnce(); publicResult(result);
- assert.equal(result.successful, 0); assert.equal(result.errors.length, 1); assert.equal(store.stats().total, 0); assert.equal(calls, 1);
- } finally { store.close(); }
- }
- });
- test('cancelling a pending request prevents record and cache writes even if an injected fetch ignores abort', async () => {
- const store = createStore(':memory:'); const controller = new AbortController(); let release;
- try {
- const collector = createChatMetadataCollector({ store, fetch: () => new Promise(resolve => { release = resolve; }) });
- collector.observe(observation(), messages()); const running = collector.runOnce({ signal: controller.signal });
- controller.abort(); const result = await running; assert.equal(result.cancelled, true);
- let cancelled = false;
- release(new Response(new ReadableStream({ cancel() { cancelled = true; } }), { headers: { 'content-type': 'application/json' } }));
- await new Promise(resolve => setImmediate(resolve)); assert.equal(cancelled, true);
- assert.equal(store.stats().total, 0); assert.equal(store.readRows("SELECT key FROM state WHERE key LIKE 'web-api:chat-metadata:%'").length, 0);
- } finally { store.close(); }
- });
- test('cancellation while streaming does not save parsed metadata', async () => {
- const store = createStore(':memory:'); const controller = new AbortController(); let streaming, cancelled = false;
- try {
- const ready = new Promise(resolve => { streaming = resolve; });
- const collector = createChatMetadataCollector({ store, fetch: async () => new Response(new ReadableStream({
- pull() { streaming(); }, cancel() { cancelled = true; }
- }), { headers: { 'content-type': 'application/json' } }) });
- collector.observe(observation(), messages()); const run = collector.runOnce({ signal: controller.signal }); await ready;
- controller.abort(); assert.equal((await run).cancelled, true); assert.equal(store.stats().total, 0); assert.equal(cancelled, true);
- // The caller is released even if a transport cannot finish its response.
- assert.equal(collector.coverage().pending, 1);
- } finally { store.close(); }
- });
- test('concurrent passes share a single request and bounded plain-text topics preserve Unicode', async () => {
- const store = createStore(':memory:'); let release, calls = 0;
- try {
- const collector = createChatMetadataCollector({ store, fetch: () => { calls++; return new Promise(resolve => { release = resolve; }); } });
- collector.observe(observation(), messages()); const first = collector.runOnce(), second = collector.runOnce();
- release(Response.json(details(chatId, '😀'.repeat(501)))); await Promise.all([first, second]);
- assert.equal(calls, 1); assert.equal([...store.getRecordByIdentity(scope()).title].length, 500); assert.equal(store.stats().versions, 1);
- } finally { store.close(); }
- });
- test('the ten-second timeout releases an unresponsive fetch and later cancels its response body', async context => {
- context.mock.timers.enable({ apis: ['setTimeout'] });
- const store = createStore(':memory:'); let release, cancelled = false;
- try {
- const collector = createChatMetadataCollector({ store, fetch: () => new Promise(resolve => { release = resolve; }) });
- collector.observe(observation(), messages()); const run = collector.runOnce();
- context.mock.timers.tick(9999); assert.equal(store.stats().total, 0);
- context.mock.timers.tick(1); const result = await run; assert.equal(result.errors[0].code, 'timeout'); publicResult(result);
- release(new Response(new ReadableStream({ cancel() { cancelled = true; } }), { headers: { 'content-type': 'application/json' } }));
- await new Promise(resolve => setImmediate(resolve)); assert.equal(cancelled, true); assert.equal(store.stats().total, 0);
- } finally { store.close(); context.mock.timers.reset(); }
- });
|