media-service.test.js 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272
  1. import test from 'node:test';
  2. import assert from 'node:assert/strict';
  3. import { mkdtemp, rm, readFile, readdir } from 'node:fs/promises';
  4. import { existsSync } from 'node:fs';
  5. import { tmpdir } from 'node:os';
  6. import { join, resolve, sep } from 'node:path';
  7. import { createStore } from '../src/store.js';
  8. import { createMediaService, imageCredential } from '../src/media-service.js';
  9. import { createAiService } from '../src/ai-service.js';
  10. const tenant = '11111111-1111-4111-8111-111111111111', user = '22222222-2222-4222-8222-222222222222';
  11. const accountId = `web-api:${tenant}:${user}`;
  12. const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+a3ioAAAAASUVORK5CYII=', 'base64');
  13. const token = (overrides = {}) => 'Bearer eyJhbGciOiJub25lIn0.' + Buffer.from(JSON.stringify({ aud: 'https://ic3.teams.office.com', tid: tenant, oid: user, exp: Math.floor(Date.now()/1000) + 3600, ...overrides })).toString('base64url') + '.fictional';
  14. const har = value => ({ log: { entries: [{ request: { url: 'https://teams.cloud.microsoft/api/fictional', headers: [{ name: 'Authorization', value: value || token() }] } }] } });
  15. const response = () => new Response(png, { headers: { 'content-type': 'image/png' } });
  16. const record = (overrides = {}) => ({ source: 'web-api', accountId, kind: 'message', externalId: '1', parentId: 'fictional-chat', title: '图片', text: '图片', raw: { images: [{ objectId: '0-ea-fictional', label: '图片' }] }, ...overrides });
  17. const deferred = () => { let resolve; const promise = new Promise(done => { resolve = done; }); return { promise, resolve }; };
  18. async function fixture(t, options = {}) {
  19. const directory = await mkdtemp(join(tmpdir(), 'teams-media-test-'));
  20. const store = createStore(join(directory, 'teams.sqlite'));
  21. store.createInstance({ id: 'default', name: '测试' });
  22. store.bindInstanceAccounts('default', [{ source: 'web-api', accountId }]);
  23. store.setState('web-api:service', { enabled: true });
  24. const requests = [];
  25. const media = createMediaService({ store, config: { dataDir: directory, historyRequestMinDelayMs: 0, historyRequestMaxDelayMs: 0 }, readSession: () => har(), fetchImpl: async (url, options) => { requests.push({ url, options }); return response(); }, ...options });
  26. t.after(async () => {
  27. await media.stop(); store.close();
  28. assert.ok(resolve(directory).startsWith(resolve(tmpdir()) + sep) && directory.split(sep).at(-1).startsWith('teams-media-test-'));
  29. await rm(directory, { recursive: true, force: true });
  30. });
  31. return { store, media, requests, directory, save: (value = record(), ingestion = 'live') => {
  32. const saved = store.upsertRecord(value, { ingestion }); return { messageId: saved.id, imageId: store.listMessageImages(saved.id)[0]?.id };
  33. } };
  34. }
  35. test('live images download automatically once, survive reopening, and appear in AI messages', async t => {
  36. const f = await fixture(t), { messageId, imageId } = f.save();
  37. assert.equal(f.media.describe(imageId).status, 'pending');
  38. await f.media.runOnce();
  39. const saved = f.media.describe(imageId);
  40. assert.equal(saved.status, 'saved'); assert.equal(saved.bytes, png.length);
  41. assert.match(saved.localPath, /\.png$/);
  42. assert.deepEqual(await readFile(saved.localPath), png);
  43. assert.equal(f.requests[0].url, 'https://as-prod.asyncgw.teams.microsoft.com/v1/objects/0-ea-fictional/views/imgo');
  44. assert.equal(f.requests[0].options.redirect, 'manual');
  45. assert.equal(f.requests[0].options.headers.Cookie, undefined);
  46. await f.media.downloadImage({ id: imageId }); await f.media.runOnce(); assert.equal(f.requests.length, 1);
  47. const query = createAiService({ store: f.store, media: f.media });
  48. assert.equal(query.getMessage({ id: messageId }).message.images[0].id, imageId);
  49. assert.doesNotMatch(JSON.stringify(query.getMessage({ id: messageId })), /Bearer|eyJhbG|objectId|asyncgw/);
  50. const second = createStore(join(f.directory, 'teams.sqlite'));
  51. try { assert.equal(second.listMessageImages(messageId)[0].status, 'saved'); } finally { second.close(); }
  52. });
  53. test('history stays on demand and later live observation can promote the same image', async t => {
  54. const f = await fixture(t), { imageId } = f.save(record(), 'history');
  55. await f.media.runOnce(); assert.equal(f.requests.length, 0); assert.equal(f.media.describe(imageId).status, 'available');
  56. f.save(record(), 'live'); await f.media.runOnce(); assert.equal(f.requests.length, 1);
  57. const old = f.save(record({ externalId: '2' }), 'history');
  58. await f.media.downloadImage({ id: old.imageId }); assert.equal(f.media.describe(old.imageId).status, 'saved');
  59. });
  60. test('history backfill queues only the selected instance and remembers future discoveries and pause', async t => {
  61. const f = await fixture(t), secondId = '44444444-4444-4444-8444-444444444444';
  62. f.store.createInstance({ id: secondId, name: 'Other' });
  63. f.store.bindInstanceAccounts(secondId, [{ source: 'web-api', accountId: 'other-account' }]);
  64. const first = f.save(record(), 'history'), other = f.save(record({ accountId: 'other-account' }), 'history');
  65. const configured = f.media.configureHistoryDownloads({ instanceId: 'default', enabled: true });
  66. assert.equal(configured.queued, 1); assert.equal(configured.counts.pending, 1);
  67. assert.equal(f.media.describe(other.imageId).status, 'available');
  68. const future = f.save(record({ externalId: 'future-history' }), 'history');
  69. assert.equal(f.media.describe(future.imageId).status, 'pending');
  70. f.media.configureHistoryDownloads({ instanceId: 'default', enabled: false });
  71. await f.media.runOnce(); assert.equal(f.requests.length, 0);
  72. const live = f.save(record({ externalId: 'new-live' }));
  73. await f.media.runOnce(); assert.equal(f.media.describe(live.imageId).status, 'saved');
  74. assert.equal(f.media.describe(first.imageId).status, 'pending');
  75. f.media.configureHistoryDownloads({ instanceId: 'default', enabled: true });
  76. await f.media.runOnce(); assert.equal(f.media.describe(first.imageId).status, 'saved'); assert.equal(f.media.describe(future.imageId).status, 'saved');
  77. assert.equal(f.media.describe(other.imageId).status, 'available');
  78. const calls = f.requests.length;
  79. assert.equal(f.media.configureHistoryDownloads({ instanceId: 'default', enabled: true }).queued, 0);
  80. await f.media.runOnce(); assert.equal(f.requests.length, calls);
  81. });
  82. test('history preference and queued progress survive a separate service process', async t => {
  83. const f = await fixture(t), saved = f.save(record(), 'history');
  84. f.media.configureHistoryDownloads({ instanceId: 'default', enabled: true });
  85. const store = createStore(join(f.directory, 'teams.sqlite'));
  86. let calls = 0;
  87. const worker = createMediaService({ store, config: { dataDir: f.directory, historyRequestMinDelayMs: 0, historyRequestMaxDelayMs: 0 },
  88. readSession: () => har(), fetchImpl: async () => { calls++; return response(); } });
  89. try {
  90. assert.equal(worker.historyDownloadStatus({ instanceId: 'default' }).enabled, true);
  91. await worker.runOnce(); assert.equal(calls, 1); assert.equal(worker.describe(saved.imageId).status, 'saved');
  92. store.upsertRecord(record({ externalId: 'discovered-after-restart' }), { ingestion: 'history' });
  93. await worker.runOnce(); assert.equal(calls, 2);
  94. } finally { await worker.stop(); store.close(); }
  95. });
  96. test('0.7.0 image rows migrate without dropping saved files or existing retry state', async t => {
  97. const f = await fixture(t), history = f.save(record(), 'history'), live = f.save(record({ externalId: 'live' }));
  98. f.store.execute('ALTER TABLE message_images DROP COLUMN queueKind');
  99. const upgraded = createStore(join(f.directory, 'teams.sqlite'));
  100. try {
  101. assert.equal(upgraded.readOne('SELECT queueKind FROM message_images WHERE id=?', [history.imageId]).queueKind, 'history');
  102. assert.equal(upgraded.readOne('SELECT queueKind FROM message_images WHERE id=?', [live.imageId]).queueKind, 'live');
  103. assert.equal(upgraded.listMessageImages(history.messageId)[0].status, 'available');
  104. assert.equal(upgraded.listMessageImages(live.messageId)[0].status, 'pending');
  105. } finally { upgraded.close(); }
  106. });
  107. test('bulk retry excludes permanent failures, preserves cooldown and skips already saved images', async t => {
  108. const f = await fixture(t), one = f.save(record(), 'history'), two = f.save(record({ externalId: 'two' }), 'history'), three = f.save(record({ externalId: 'three' }), 'history');
  109. await f.media.downloadImage({ id: three.imageId });
  110. f.store.execute("UPDATE message_images SET status='failed',attempts=8,errorCode='download_failed' WHERE id=?", [one.imageId]);
  111. f.store.execute("UPDATE message_images SET status='failed',attempts=8,errorCode='image_unavailable' WHERE id=?", [two.imageId]);
  112. f.store.setState(`media:cooldown:${accountId}`, { until: Date.now() + 100000, reason: 'rate_limited' });
  113. const result = f.media.configureHistoryDownloads({ instanceId: 'default', enabled: true, retryFailed: true });
  114. assert.equal(result.retried, 1); assert.equal(result.counts.saved, 1); assert.equal(result.counts.failed, 1);
  115. assert.equal(f.media.describe(two.imageId).status, 'failed');
  116. await f.media.runOnce(); assert.equal(f.requests.length, 1);
  117. });
  118. test('per-instance pacing is persisted and live images take priority over historical backlog', async t => {
  119. let time = Date.now();
  120. const f = await fixture(t, { now: () => time, random: () => 0.5, config: { historyRequestMinDelayMs: 2000, historyRequestMaxDelayMs: 5000 } });
  121. f.media.configureHistoryDownloads({ instanceId: 'default', enabled: true });
  122. const old = f.save(record(), 'history'), live = f.save(record({ externalId: 'live' }));
  123. await f.media.runOnce(); assert.equal(f.requests.length, 1); assert.equal(f.media.describe(live.imageId).status, 'saved');
  124. assert.equal(f.store.getState('media:pacing:default').until, time + 3500);
  125. time += 3499; await f.media.runOnce(); assert.equal(f.requests.length, 1);
  126. time++; await f.media.runOnce(); assert.equal(f.requests.length, 2); assert.equal(f.media.describe(old.imageId).status, 'saved');
  127. });
  128. test('a large first-instance backlog gives another ready instance a turn', async t => {
  129. const secondId = '44444444-4444-4444-8444-444444444444', secondUser = '33333333-3333-4333-8333-333333333333';
  130. const f = await fixture(t, { readSession: id => har(token({ oid: id === 'default' ? user : secondUser })) });
  131. f.store.createInstance({ id: secondId, name: 'Other' }); f.store.bindInstanceAccounts(secondId, [{ source: 'web-api', accountId: `web-api:${tenant}:${secondUser}` }]);
  132. f.store.setState(`instance:${secondId}:web-api:service`, { enabled: true });
  133. for (const instanceId of ['default', secondId]) f.media.configureHistoryDownloads({ instanceId, enabled: true });
  134. f.store.transaction(() => { for (let i = 0; i < 120; i++) f.save(record({ externalId: `old-${i}` }), 'history'); });
  135. const other = f.save(record({ accountId: `web-api:${tenant}:${secondUser}` }), 'history');
  136. await f.media.runOnce(); assert.equal(f.requests.length, 3); assert.equal(f.media.describe(other.imageId).status, 'saved');
  137. });
  138. test('waiting for renewed credentials pauses the account without consuming per-image retry budgets', async t => {
  139. let time = Date.now(), session = har(token({ exp: 1 }));
  140. const f = await fixture(t, { now: () => time, readSession: () => session });
  141. f.media.configureHistoryDownloads({ instanceId: 'default', enabled: true });
  142. const first = f.save(record(), 'history'); f.save(record({ externalId: 'second' }), 'history');
  143. for (let i = 0; i < 10; i++) { await f.media.runOnce(); time += 60001; }
  144. assert.equal(f.requests.length, 0); assert.equal(f.store.readOne('SELECT SUM(attempts) n FROM message_images').n, 0);
  145. session = har(token({ exp: Math.floor(time / 1000) + 3600 }));
  146. await f.media.runOnce(); assert.equal(f.media.describe(first.imageId).status, 'saved');
  147. });
  148. test('editing a message retains its saved image as evidence from an earlier version', async t => {
  149. const f = await fixture(t), { imageId } = f.save(); await f.media.runOnce();
  150. const path = f.media.describe(imageId).localPath;
  151. f.save(record({ raw: {}, text: 'edited' }));
  152. assert.equal(f.media.describe(imageId).fromEarlierVersion, true); assert.equal(existsSync(path), true);
  153. f.save(); assert.equal(f.media.describe(imageId).fromEarlierVersion, false);
  154. });
  155. test('credential selection requires the exact instance identity, IC3 audience, trusted source and current expiry', async t => {
  156. const expected = token(); assert.equal(imageCredential(har(expected), accountId), expected);
  157. for (const claims of [{ oid: tenant }, { tid: user }, { aud: 'https://graph.microsoft.com' }, { exp: 1 }]) assert.throws(() => imageCredential(har(token(claims)), accountId), /session_expired/);
  158. const untrusted = har(); untrusted.log.entries[0].request.url = 'https://evil.invalid/';
  159. assert.throws(() => imageCredential(untrusted, accountId));
  160. const f = await fixture(t, { readSession: () => har(token({ oid: tenant })) });
  161. const { imageId } = f.save(); await f.media.runOnce();
  162. assert.equal(f.requests.length, 0); assert.equal(f.media.describe(imageId).errorCode, 'session_expired');
  163. });
  164. test('different instances use independent credentials and do not share cached image files', async t => {
  165. const secondUser = '33333333-3333-4333-8333-333333333333', instanceId = '44444444-4444-4444-8444-444444444444';
  166. const other = `web-api:${tenant}:${secondUser}`, calls = [];
  167. const f = await fixture(t, { readSession: id => har(token({ oid: id === 'default' ? user : secondUser })), fetchImpl: async (url, options) => { calls.push(options.headers.Authorization); return response(); } });
  168. f.store.createInstance({ id: instanceId, name: '第二实例' }); f.store.bindInstanceAccounts(instanceId, [{ source: 'web-api', accountId: other }]);
  169. f.store.setState(`instance:${instanceId}:web-api:service`, { enabled: true });
  170. const one = f.save(), two = f.save(record({ accountId: other }));
  171. await f.media.runOnce();
  172. assert.equal(calls.length, 2); assert.notEqual(calls[0], calls[1]);
  173. assert.notEqual(f.media.describe(one.imageId).localPath, f.media.describe(two.imageId).localPath);
  174. });
  175. test('automatic image downloads follow the instance collection switch', async t => {
  176. const f = await fixture(t); f.store.setState('web-api:service', { enabled: false });
  177. f.save(); await f.media.runOnce(); assert.equal(f.requests.length, 0);
  178. f.store.setState('web-api:service', { enabled: true }); await f.media.runOnce(); assert.equal(f.requests.length, 1);
  179. });
  180. test('a large cooled-down instance queue cannot starve another instance', async t => {
  181. const secondUser = '33333333-3333-4333-8333-333333333333', instanceId = '44444444-4444-4444-8444-444444444444';
  182. const other = `web-api:${tenant}:${secondUser}`;
  183. const f = await fixture(t, { readSession: id => har(token({ oid: id === 'default' ? user : secondUser })) });
  184. f.store.createInstance({ id: instanceId, name: '第二实例' }); f.store.bindInstanceAccounts(instanceId, [{ source: 'web-api', accountId: other }]);
  185. f.store.setState(`instance:${instanceId}:web-api:service`, { enabled: true });
  186. f.store.transaction(() => { for (let i = 0; i < 120; i++) f.save(record({ externalId: String(i) })); });
  187. f.store.setState(`media:cooldown:${accountId}`, { until: Date.now() + 120000 });
  188. const next = f.save(record({ accountId: other }));
  189. await f.media.runOnce(); assert.equal(f.requests.length, 1); assert.equal(f.media.describe(next.imageId).status, 'saved');
  190. });
  191. test('permanent failures never save HTML, SVG, redirects or oversized image responses', async t => {
  192. for (const [value, expected] of [
  193. [() => new Response('<html>private-error</html>', { headers: { 'content-type': 'image/png' } }), 'invalid_image'],
  194. [() => new Response('<svg/>', { headers: { 'content-type': 'image/svg+xml' } }), 'unsupported_image'],
  195. [() => new Response('', { status: 302, headers: { location: 'https://evil.invalid/?token=secret' } }), 'redirect_blocked'],
  196. [() => new Response(png, { headers: { 'content-type': 'image/png', 'content-length': '30000000' } }), 'image_too_large'],
  197. [() => new Response('', { status: 404 }), 'image_unavailable']]) {
  198. const f = await fixture(t, { fetchImpl: async () => value() }); const { imageId } = f.save();
  199. const result = await f.media.downloadImage({ id: imageId });
  200. assert.equal(result.status, 'failed'); assert.equal(result.errorCode, expected);
  201. assert.equal(existsSync(f.store.mediaPath(imageId)), false); assert.doesNotMatch(JSON.stringify(result), /private-error|evil|secret/);
  202. }
  203. const f = await fixture(t, { maxBytes: 10 }); const { imageId } = f.save();
  204. assert.equal((await f.media.downloadImage({ id: imageId })).errorCode, 'image_too_large');
  205. });
  206. test('429 persists cooldown across images and manual retries, then recovers', async t => {
  207. let time = Date.now(), calls = 0;
  208. const f = await fixture(t, { now: () => time, fetchImpl: async () => ++calls === 1 ? new Response('', { status: 429, headers: { 'retry-after': '120' } }) : response() });
  209. const { imageId } = f.save(); f.save(record({ externalId: '2' }));
  210. await f.media.runOnce(); assert.equal(calls, 1);
  211. assert.equal(f.media.describe(imageId).errorCode, 'rate_limited');
  212. await f.media.downloadImage({ id: imageId }); assert.equal(calls, 1);
  213. time += 120001; await f.media.runOnce(); assert.equal(calls, 3); assert.equal(f.media.describe(imageId).status, 'saved');
  214. });
  215. test('long server Retry-After values are respected without retrying before the requested time', async t => {
  216. const time = Date.now();
  217. const f = await fixture(t, { now: () => time, fetchImpl: async () => new Response('', { status: 429, headers: { 'retry-after': '7200' } }) });
  218. const { imageId } = f.save(); await f.media.runOnce();
  219. assert.equal(f.store.readOne('SELECT nextAttemptAt FROM message_images WHERE id=?', [imageId]).nextAttemptAt, time + 7200000);
  220. });
  221. test('download timeout releases its lease and reports retryable interruption', async t => {
  222. const f = await fixture(t, { timeoutMs: 15, fetchImpl: async (url, { signal }) => new Promise((resolve, reject) => signal.addEventListener('abort', () => reject(new Error('sensitive-url')), { once: true })) });
  223. const { imageId } = f.save();
  224. const keepAlive = setTimeout(() => {}, 1000); t.after(() => clearTimeout(keepAlive));
  225. const result = await f.media.downloadImage({ id: imageId });
  226. assert.equal(result.status, 'retrying'); assert.equal(result.errorCode, 'download_interrupted');
  227. assert.equal(f.store.readOne('SELECT leaseToken FROM message_images WHERE id=?', [imageId]).leaseToken, null);
  228. });
  229. test('an abandoned download lease and an expired session recover with the refreshed instance session', async t => {
  230. let time = Date.now(), current = token({ exp: 1 });
  231. const f = await fixture(t, { now: () => time, readSession: () => har(current) });
  232. const { imageId } = f.save();
  233. f.store.execute("UPDATE message_images SET status='downloading',leaseToken='abandoned',leaseUntil=? WHERE id=?", [time - 1, imageId]);
  234. await f.media.runOnce(); assert.equal(f.media.describe(imageId).errorCode, 'session_expired');
  235. assert.equal(f.requests.length, 0);
  236. time += 60001; current = token(); await f.media.runOnce();
  237. assert.equal(f.requests.length, 1); assert.equal(f.media.describe(imageId).status, 'saved');
  238. });
  239. test('deleting an account cleans saved files; a racing download cannot recreate them', async t => {
  240. const f = await fixture(t), saved = f.save(); await f.media.runOnce();
  241. const path = f.media.describe(saved.imageId).localPath;
  242. assert.equal(f.store.previewAccountDeletion({ source: 'web-api', accountId }).counts.images, 1);
  243. f.store.deleteAccountRecords({ source: 'web-api', accountId }); f.store.collectMediaGarbage();
  244. assert.equal(existsSync(path), false); assert.throws(() => f.media.describe(saved.imageId));
  245. const entered = deferred(), finish = deferred();
  246. const race = await fixture(t, { fetchImpl: async () => { entered.resolve(); await finish.promise; return response(); } });
  247. const item = race.save(), download = race.media.downloadImage({ id: item.imageId });
  248. const checked = assert.rejects(download, /image_not_found/);
  249. await entered.promise; race.store.deleteAccountRecords({ source: 'web-api', accountId }); finish.resolve(); await checked;
  250. race.store.collectMediaGarbage(); assert.equal(existsSync(race.store.mediaPath(item.imageId)), false);
  251. assert.deepEqual(await readdir(join(race.directory, 'media')), []);
  252. });
  253. test('inflight leases prevent duplicate downloads across MCP and collector processes', async t => {
  254. const entered = deferred(), finish = deferred(); let calls = 0;
  255. const f = await fixture(t, { fetchImpl: async () => { calls++; entered.resolve(); await finish.promise; return response(); } });
  256. const { imageId } = f.save(); const first = f.media.downloadImage({ id: imageId }); await entered.promise;
  257. const other = createMediaService({ store: f.store, config: { dataDir: f.directory }, readSession: () => har(), fetchImpl: async () => { calls++; return response(); } });
  258. try {
  259. assert.equal((await other.downloadImage({ id: imageId })).status, 'downloading');
  260. finish.resolve(); await first; assert.equal(calls, 1);
  261. } finally { finish.resolve(); await other.stop(); }
  262. });