import { test } from 'node:test'; import assert from 'node:assert/strict'; import { once } from 'node:events'; import http from 'node:http'; import { createStore } from '../src/store.js'; import { createServer } from '../src/server.js'; async function fixture(fn, network, extras = {}) { const store = createStore(':memory:'); const config = { port: 0, localToken: 'local-test', pairingToken: 'extension-test', mcpToken:'mcp-test', dataDir: 'temp-test', rotatePairing() { return this.pairingToken = 'new-token'; } }; const graph = { status: () => ({ configured: false }), beginLogin: async () => ({ url: 'https://login.microsoftonline.com/' }), sync: async () => ({ ok: true }), completeLogin: async () => { throw Error(); } }; const server = createServer({ store, config, graph, network, ...extras }); server.listen(0, '127.0.0.1'); await once(server, 'listening'); config.port = server.address().port; const base = `http://127.0.0.1:${config.port}`; try { await fn({ store, config, base }); } finally { await new Promise(resolve => server.close(resolve)); store.close(); } } const payload = { accountId: 'work@example.com', records: [{ kind: 'message', externalId: 'm1', title: 'test', text: '', raw: { provenance: 'dom' } }], page: { url: 'https://teams.microsoft.com/v2/', signedIn: true, view: 'chat', coverage: '已加载内容' } }; const post = (base, path, token, body, extra = {}) => fetch(base + path, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}`, ...extra }, body: JSON.stringify(body) }); test('local image download requires the operation token and serves local bytes with safe headers', async () => { const id = '11111111-1111-4111-8111-111111111111', calls = [], image = Buffer.from('local-test-image'); await fixture(async ({ base }) => { assert.equal((await post(base, `/api/images/${id}/download`, '', {})).status, 403); assert.equal((await post(base, `/api/images/${id}/download`, '', {}, { 'X-Local-Token': 'local-test' })).status, 200); assert.deepEqual(calls, [{ id }]); const result = await fetch(base + `/api/images/${id}/content?download=1`); assert.equal(result.status, 200); assert.deepEqual(Buffer.from(await result.arrayBuffer()), image); assert.equal(result.headers.get('content-type'), 'image/png'); assert.equal(result.headers.get('x-content-type-options'), 'nosniff'); assert.match(result.headers.get('content-disposition'), /^attachment/); assert.equal((await fetch(base + `/api/images/${id}/content`, { headers: { Origin: 'https://evil.invalid' } })).status, 403); }, undefined, { media: { downloadImage: args => { calls.push(args); return { id, status: 'saved' }; }, readImage: async () => ({ bytes: image, mimeType: 'image/png', fileName: `${id}.png` }) } }); }); test('historical image controls require local authorization, valid instance and boolean settings', async () => { const calls = [], network = { status: () => ({}), listInstances: () => [] }; await fixture(async ({ base, store }) => { store.createInstance({ id: 'default', name: 'Images' }); const headers = { 'X-Local-Token': 'local-test' }, route = '/api/instances/default/images/backfill'; assert.equal((await post(base, route, '', { enabled: true })).status, 403); assert.equal((await post(base, route, '', { enabled: 'true' }, headers)).status, 400); assert.equal((await post(base, route, '', { enabled: true, retryFailed: 'true' }, headers)).status, 400); assert.equal((await post(base, '/api/instances/11111111-1111-4111-8111-111111111111/images/backfill', '', { enabled: true }, headers)).status, 404); assert.equal(calls.length, 0); assert.equal((await post(base, route, '', { enabled: true, retryFailed: true }, headers)).status, 200); assert.deepEqual(calls[0], { instanceId: 'default', enabled: true, retryFailed: true }); assert.equal((await post(base, route, '', { enabled: false }, headers)).status, 200); assert.deepEqual(calls[1], { instanceId: 'default', enabled: false, retryFailed: false }); }, network, { media: { configureHistoryDownloads: args => { calls.push(args); return { enabled: args.enabled }; } } }); }); test('demo and browser accounts can be previewed and purged without an instance, preserving other scopes', async () => { const order = [], headers = { 'X-Local-Token': 'local-test' }; await fixture(async ({ base, store }) => { await post(base, '/api/demo', '', {}, headers); const initialDemo = await post(base, '/api/local-records/preview', '', { source: 'demo', accountId: 'demo' }, headers); assert.equal(initialDemo.status, 200); assert.equal((await initialDemo.json()).counts.records, 2); await post(base, '/api/extension/events', 'extension-test', payload); const edited = { ...payload, records: [{ ...payload.records[0], text: 'Fictional edit' }] }; await post(base, '/api/extension/events', 'extension-test', edited); const scope = { source: 'browser', accountId: `browser:${payload.accountId}` }; store.upsertRecord({ ...scope, source: 'demo', kind: 'message', externalId: 'same-account-other-source', text: 'Preserve other source' }); store.upsertRecord({ ...scope, accountId: 'browser:other', kind: 'event', externalId: 'other-browser', text: 'Preserve other account' }); store.createInstance({ id: 'default', name: 'Existing API instance' }); store.bindInstanceAccounts('default', [{ source: 'web-api', accountId: scope.accountId }]); store.upsertRecord({ ...scope, source: 'web-api', kind: 'message', externalId: 'api-message', text: 'Preserve API account' }); store.setState('web-api:service', { enabled: true }); const before = store.listRecords().items.filter(row => !(row.source === scope.source && row.accountId === scope.accountId)); const accounts = await (await fetch(base + '/api/local-records/accounts')).json(); assert.deepEqual(accounts.items, [ { source: 'browser', accountId: scope.accountId, records: 1 }, { source: 'browser', accountId: 'browser:other', records: 1 }, { source: 'demo', accountId: scope.accountId, records: 1 }, { source: 'demo', accountId: 'demo', records: 2 }, ].sort((a, b) => a.source.localeCompare(b.source) || a.accountId.localeCompare(b.accountId))); const preview = await post(base, '/api/local-records/preview', '', scope, headers); assert.equal(preview.status, 200); assert.deepEqual((await preview.json()).counts, { records: 1, versions: 2, changes: 2, liveObservations: 0, webhookDeliveries: 0, images: 0 }); assert.equal(store.listRecords(scope).total, 1); const result = await post(base, '/api/local-records/delete', '', { ...scope, confirmation: scope.accountId }, headers); assert.equal(result.status, 200); assert.equal((await result.json()).deleted, true); assert.deepEqual(store.listRecords().items, before); assert.equal(store.getState('web-api:service').enabled, true); assert.equal(store.previewAccountDeletion(scope).counts.versions, 0); assert.deepEqual(order, ['pause', 'resume']); const updated = await (await fetch(base + '/api/local-records/accounts')).json(); assert.equal(updated.items.some(a => a.source === scope.source && a.accountId === scope.accountId), false); const demo = await post(base, '/api/local-records/delete', '', { source: 'demo', accountId: 'demo', confirmation: 'demo' }, headers); assert.equal(demo.status, 200); assert.equal((await demo.json()).counts.records, 2); assert.equal(store.listRecords({ source: 'demo', accountId: scope.accountId }).total, 1); }, undefined, { webhooks: { status: () => ({ running: true }), stop: async () => { order.push('pause'); }, start: () => { order.push('resume'); } } }); }); test('local record deletion rejects unauthorized, malformed, unsupported and instance-bound scopes', async () => fixture(async ({ base, store }) => { const headers = { 'X-Local-Token': 'local-test' }, scope = { source: 'demo', accountId: 'demo' }; store.upsertRecord({ ...scope, kind: 'message', externalId: 'keep', text: 'Fictional' }); for (const path of ['/api/local-records/preview', '/api/local-records/delete']) { assert.equal((await post(base, path, '', scope)).status, 403); assert.equal((await post(base, path, '', scope, { ...headers, Origin: 'https://untrusted.example' })).status, 403); for (const invalid of [{}, { source: 'web-api', accountId: 'demo' }, { source: 'graph', accountId: 'demo' }, { source: 'demo', accountId: '' }, { source: 'demo', accountId: 'demo\u0000' }]) assert.equal((await post(base, path, '', { ...invalid, confirmation: invalid.accountId }, headers)).status, 400); } assert.equal((await post(base, '/api/local-records/delete', '', scope, headers)).status, 400); assert.equal((await post(base, '/api/local-records/delete', '', { ...scope, confirmation: 'other' }, headers)).status, 400); store.createInstance({ id: 'default', name: 'Bound' }); store.bindInstanceAccounts('default', [scope]); assert.deepEqual((await (await fetch(base + '/api/local-records/accounts')).json()).items, []); assert.equal((await post(base, '/api/local-records/preview', '', scope, headers)).status, 400); assert.equal((await post(base, '/api/local-records/delete', '', { ...scope, confirmation: 'demo' }, headers)).status, 400); assert.equal(store.listRecords(scope).total, 1); })); test('local deletion rechecks ownership after awaiting the notification dispatcher', async () => { const scope = { source: 'browser', accountId: 'browser:late-bound' }; let bind, resumed = 0; await fixture(async ({ base, store }) => { store.createInstance({ id: 'default', name: 'Late binding' }); store.upsertRecord({ ...scope, kind: 'message', externalId: 'keep', text: 'Fictional' }); bind = () => store.bindInstanceAccounts('default', [scope]); const response = await post(base, '/api/local-records/delete', '', { ...scope, confirmation: scope.accountId }, { 'X-Local-Token': 'local-test' }); assert.equal(response.status, 400); assert.equal(resumed, 1); assert.equal(store.listRecords(scope).total, 1); }, undefined, { webhooks: { status: () => ({ running: true }), stop: async () => { bind(); }, start: () => { resumed++; } } }); }); test('instance mutation routes validate local authorization and account membership before dispatch', async () => { const calls = [], deliveryOrder = [], network = { status: () => ({}), listInstances: () => [], start: async id => { calls.push(['start', id]); return { running: true }; }, update: async (id, settings) => { calls.push(['settings', id, settings]); return {}; }, deleteRecords: async (id, scope) => { calls.push(['delete', id, scope]); deliveryOrder.push('delete'); return { deleted: true }; }, importPresence: async () => { throw new Error('secret-auth-capture-path'); } }; await fixture(async ({ base, store }) => { store.createInstance({ id: 'default', name: 'Fictional instance' }); store.bindInstanceAccounts('default', [{ source: 'web-api', accountId: 'account-a' }]); const headers = { 'X-Local-Token': 'local-test' }; assert.equal((await post(base, '/api/instances/default/start', '', {})).status, 403); assert.equal((await post(base, '/api/instances/default/start', '', {}, headers)).status, 200); assert.deepEqual(calls[0], ['start', 'default']); assert.equal((await post(base, '/api/instances/default/settings', '', { keepOnline: 'true' }, headers)).status, 400); assert.equal((await post(base, '/api/instances/default/settings', '', { keepOnline: true }, headers)).status, 200); const scope = { source: 'web-api', accountId: 'account-a' }; assert.equal((await post(base, '/api/instances/default/records/preview', '', scope, headers)).status, 200); assert.equal((await post(base, '/api/instances/default/records/delete', '', scope, headers)).status, 400); assert.equal((await post(base, '/api/instances/default/records/delete', '', { ...scope, accountId: 'account-b', confirmation: 'account-b' }, headers)).status, 400); assert.equal(calls.length, 2); assert.equal((await post(base, '/api/instances/default/records/delete', '', { ...scope, confirmation: 'account-a' }, headers)).status, 200); assert.equal(calls[2][0], 'delete'); assert.equal(calls[2][1], 'default'); assert.deepEqual(deliveryOrder, ['stop', 'delete', 'start']); const rejected = await post(base, '/api/instances/default/presence/import', '', { fileName: '../wrong.har' }, headers); assert.equal(rejected.status, 400); assert.doesNotMatch(await rejected.text(), /secret-auth/); }, network, { webhooks: { status: () => ({ running: true }), stop: async () => { deliveryOrder.push('stop'); }, start: () => { deliveryOrder.push('start'); } } }); }); test('REST and export combine instance and exclusive time range; invalid or unknown filters fail closed', async () => fixture(async ({ base, store }) => { store.createInstance({ id: 'default', name: 'Fictional instance' }); store.bindInstanceAccounts('default', [{ source: 'web-api', accountId: 'account-a' }]); for (const [id, accountId, occurredAt] of [['first','account-a','2026-09-08T00:00:00Z'],['end','account-a','2026-09-08T01:00:00Z'],['other','account-b','2026-09-08T00:00:00Z']]) store.upsertRecord({ source:'web-api',accountId,kind:'message',externalId:id,text:id,occurredAt }); const filters = new URLSearchParams({ instanceId:'default',from:'2026-09-08T08:00:00+08:00',to:'2026-09-08T09:00:00+08:00' }); const response = await (await fetch(base+'/api/records?'+filters)).json(); assert.equal(response.total,1); assert.equal(response.items[0].externalId,'first'); const exported = await (await fetch(base+'/api/export?'+filters)).text(); assert.equal(exported.trim().split('\n').length,1); for (const filter of ['instanceId=unknown','instanceId=11111111-1111-1111-1111-111111111111','from=2026-09-08T00:00:00','from=2026-02-30T00:00:00Z','from=2026-09-09T00:00:00Z&to=2026-09-08T00:00:00Z']) assert.equal((await fetch(base+'/api/records?'+filter)).status,400); })); test('MCP HTTP requires its own Bearer token and same-origin loopback access before parsing protocol messages',async()=>{ const calls=[]; const mcpHandler=async(req,res,body)=>{calls.push(body);res.writeHead(200,{'Content-Type':'application/json'});res.end(JSON.stringify({jsonrpc:'2.0',id:body.id,result:{ok:true}}));}; await fixture(async({base})=>{ const message={jsonrpc:'2.0',id:1,method:'tools/list'}; assert.equal((await post(base,'/mcp','wrong',message)).status,401); assert.equal((await post(base,'/mcp','mcp-test',message,{Origin:'https://untrusted.example'})).status,403); assert.equal((await post(base,'/mcp','mcp-test',message)).status,200);assert.equal(calls.length,1); assert.equal((await post(base,'/mcp','mcp-test',{data:'x'.repeat(1024*1024)})).status,413); const status=await(await fetch(base+'/api/status')).json();assert.equal(status.mcp.available,true);assert.equal(status.mcpToken,undefined); },undefined,{mcpHandler}); }); test('API worker controls require local authorization and never expose internal login exceptions', async () => { const calls = []; const network = { status: () => ({ running: true, login: { state: 'waiting' } }), beginLogin: async () => { calls.push('login'); return { state: 'opening' }; }, finishLogin: async () => { throw new Error('Bearer secret-browser-request'); }, stop: async () => { calls.push('stop'); return { running: false }; } }; await fixture(async ({ base }) => { assert.equal((await post(base, '/api/network/login', '', {})).status, 403); assert.equal((await post(base, '/api/network/login', '', {}, { 'X-Local-Token': 'local-test', Origin: 'https://evil.example' })).status, 403); const response = await post(base, '/api/network/login', '', {}, { 'X-Local-Token': 'local-test' }); assert.equal(response.status, 200); assert.deepEqual(calls, ['login']); const status = await (await fetch(base + '/api/status')).json(); assert.equal(status.network.running, true); const denied = await post(base, '/api/network/login/finish', '', {}, { 'X-Local-Token': 'local-test' }); assert.equal(denied.status, 400); assert.doesNotMatch(await denied.text(), /secret-browser-request|Bearer/); }, network); }); test('扩展配对、批量入库、幂等上传、历史和导出完整闭环', async () => fixture(async ({ base, store }) => { const ping = await post(base, '/api/extension/ping', 'extension-test', {}); assert.equal(ping.status, 200); const first = await post(base, '/api/extension/events', 'extension-test', payload); assert.equal(first.status, 200); assert.equal((await first.json()).changed, 1); const again = await post(base, '/api/extension/events', 'extension-test', payload); assert.equal((await again.json()).changed, 0); const result = await (await fetch(base + '/api/records?kind=message')).json(); assert.equal(result.total, 1); assert.equal(result.items[0].accountId, 'browser:work@example.com'); assert.equal(result.items[0].source, 'browser'); assert.equal(result.items[0].text, payload.records[0].text); const edited = structuredClone(payload); edited.records[0].text = 'updated'; await post(base, '/api/extension/events', 'extension-test', edited); const detail = await (await fetch(base + '/api/records/' + result.items[0].id)).json(); assert.equal(detail.versions.length, 2); const exported = await fetch(base + '/api/export?kind=message'); assert.match(exported.headers.get('content-disposition'), /attachment/); assert.equal(JSON.parse((await exported.text()).trim()).text, 'updated'); assert.equal(store.getState('browser:lastHeartbeat').signedIn, true); })); test('跨站、错误令牌、DNS rebinding 与越权写入被拒绝', async () => fixture(async ({ base, config }) => { assert.equal((await post(base, '/api/extension/events', 'wrong', payload)).status, 401); assert.equal((await post(base, '/api/extension/events', 'extension-test', payload, { Origin: 'https://evil.example' })).status, 403); assert.equal((await fetch(base + '/api/status', { headers: { Origin: 'https://evil.example' } })).status, 403); assert.equal((await fetch(base + '/api/status', { headers: { 'Sec-Fetch-Site': 'cross-site' } })).status, 403); // Native fetch normalizes Host, so use raw HTTP to exercise DNS rebinding protection. const hostStatus = await new Promise((resolve, reject) => http.get(base + '/api/status', { headers: { Host: `evil.example:${config.port}` } }, res => { res.resume(); resolve(res.statusCode); }).on('error', reject)); assert.equal(hostStatus, 403); assert.equal((await post(base, '/api/demo', 'extension-test', {})).status, 403); assert.equal((await post(base, '/api/demo', '', {}, { 'X-Local-Token': 'local-test' })).status, 200); const status = await (await fetch(base + '/api/status')).json(); assert.equal(status.localToken, 'local-test'); })); test('无效批次不会部分写入;大请求拒绝,浏览器不能伪造 source', async () => fixture(async ({ base, store }) => { const invalid = structuredClone(payload); invalid.records.push({ kind: 'invalid' }); assert.equal((await post(base, '/api/extension/events', 'extension-test', invalid)).status, 400); assert.equal(store.stats().total, 0); const excessive = structuredClone(payload); excessive.records = Array.from({ length: 201 }, () => payload.records[0]); assert.equal((await post(base, '/api/extension/events', 'extension-test', excessive)).status, 400); const huge = await post(base, '/api/extension/events', 'extension-test', { data: 'x'.repeat(1024 * 1024) }); assert.equal(huge.status, 413); const forged = structuredClone(payload); forged.records[0].source = 'graph'; forged.records[0].accountId = 'victim'; assert.equal((await post(base, '/api/extension/events', 'extension-test', forged)).status, 200); assert.equal(store.listRecords().items[0].source, 'browser'); })); test('扩展预检允许准确的扩展来源;旋转后旧配对密钥失效', async () => fixture(async ({ base }) => { const origin = 'chrome-extension://' + 'a'.repeat(32); const options = await fetch(base + '/api/extension/events', { method: 'OPTIONS', headers: { Origin: origin } }); assert.equal(options.status, 204); assert.equal(options.headers.get('Access-Control-Allow-Origin'), origin); await post(base, '/api/extension/ping', 'extension-test', { accountId: 'work' }); await post(base, '/api/extension/events', 'extension-test', payload); assert.equal((await post(base, '/api/pairing/rotate', '', {}, { 'X-Local-Token': 'local-test' })).status, 200); const reset = await (await fetch(base + '/api/status')).json(); assert.equal(reset.pairing, null); assert.equal(reset.browser, null); assert.equal(reset.extension, null); assert.equal(reset.stats.total, 1); assert.equal((await post(base, '/api/extension/ping', 'extension-test', {})).status, 401); assert.equal((await post(base, '/api/extension/ping', 'new-token', {})).status, 200); })); test('静态页面强制 CSP,路径遍历无法获取数据文件,OAuth 失败跳回本地页面', async () => fixture(async ({ base }) => { const page = await fetch(base + '/'); assert.equal(page.status, 200); assert.match(page.headers.get('Content-Security-Policy'), /frame-ancestors 'none'/); assert.equal((await fetch(base + '/data/pairing.json')).status, 404); for (const query of ['limit=1.5', 'offset=Infinity', 'offset=0.5']) assert.equal((await fetch(base + '/api/records?' + query)).status, 400); const login = await fetch(base + '/auth/callback?code=untrusted', { redirect: 'manual' }); assert.equal(login.status, 303); assert.equal(login.headers.get('Location'), '/?login=failed'); })); test('配对状态与页面心跳分开,诊断指出已开启但未注入,零条采集仍更新心跳', async () => fixture(async ({ base }) => { await post(base, '/api/extension/ping', 'extension-test', { accountId: 'work' }); let status = await (await fetch(base + '/api/status')).json(); assert.ok(status.pairing.at); assert.equal(status.browser, null); const diagnostic = { accountId: 'work', version: '0.1.1', enabled: true, teamsTabCount: 1, readyTabCount: 0, error: '页面脚本未连接' }; const sent = await post(base, '/api/extension/status', 'extension-test', diagnostic); assert.equal(sent.status, 200); status = await (await fetch(base + '/api/status')).json(); assert.equal(status.extension.error, '页面脚本未连接'); assert.equal(status.extension.enabled, true); assert.equal(status.browser, null); assert.equal((await post(base, '/api/extension/status', 'wrong', diagnostic)).status, 401); assert.equal((await post(base, '/api/extension/status', 'extension-test', { ...diagnostic, readyTabCount: 2 })).status, 400); assert.equal((await post(base, '/api/extension/status', 'extension-test', { ...diagnostic, teamsTabCount: '1' })).status, 400); const zero = { ...payload, records: [] }; assert.equal((await post(base, '/api/extension/events', 'extension-test', zero)).status, 200); status = await (await fetch(base + '/api/status')).json(); assert.ok(status.browser.at); assert.equal(status.browser.received, 0); }));