Files
stack/packages/bus/tests/p5-telemetry-fixture.mjs

79 lines
6.3 KiB
JavaScript

// Fresh, made-up instance and local management listener only; no worker/provider.
import http from 'node:http';
import { createHash, randomBytes } from 'node:crypto';
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { startBroker } from '../src/runtime.mjs';
import { Registry } from '../../seat/src/session.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
// Row 333 R3 (#1831): every wait races a real-timer deadline, captured here before any test mocks
// setTimeout, so a missed event fails by name instead of hanging the file. R4: the real setImmediate
// too, for the yield after a poll, which now runs inside that poll's deadline.
const realSetTimeout = globalThis.setTimeout, realClearTimeout = globalThis.clearTimeout, realSetImmediate = globalThis.setImmediate;
export const WAIT_MS = 5000;
function deadline(promise, what, ms) {
let timer;
const expired = new Promise((_, reject) => { timer = realSetTimeout(() => reject(new Error(`p5 fixture: ${what} within ${ms} ms`)), ms); });
return Promise.race([promise, expired]).finally(() => realClearTimeout(timer));
}
export async function telemetryFixture(t, { foreign = false, hold = false, waitMs = WAIT_MS, orgMode = false } = {}) {
const root = mkdtempSync(join(tmpdir(), 'p5-telemetry-')), config = join(root,'config'), data = join(root,'data');
mkdirSync(config,{mode:0o700}); mkdirSync(data,{mode:0o700});
const rolesDir = rolesCopy(config), doc = businessDoc(config,'demo');
doc.plugins = { usage:'cliproxy-queue', harness:['pi'], 'usage-source':['transcript'], 'limit-check':['token-limit'] };
doc.usage = { cliproxyQueue:{pollSeconds:1} };
writeJson(join(config,'businesses/demo.json'),doc);
mkdirSync(join(config,'secrets'),{recursive:true,mode:0o700});
writeFileSync(join(config,'secrets/proxy-management.key'),'p5-r1-made-up-management',{mode:0o600});
new Registry(data);
const tag = createHash('sha256').update(config).digest('hex').slice(0,12);
const own = `msk-${tag}-sentinel-${randomBytes(32).toString('base64url')}`;
const other = `msk-ffffffffffff-sentinel-${randomBytes(32).toString('base64url')}`;
const state = { keys:[foreign?other:own], calls:[], queued:[{api_key:'msk-r1-unknown-fake',source:'p5-r1-upstream-canary',failed:false,tokens:{input_tokens:1,output_tokens:2}}], held:[], hold };
const logs=[], waiters=[];
const stderr = process.stderr.write;
t.mock.method(process.stderr,'write',function(chunk,...args) {
const text=String(chunk);logs.push(text);
for(const waiter of [...waiters]) if(text.includes(waiter.fragment) && logs.length>waiter.from) { waiters.splice(waiters.indexOf(waiter),1);waiter.resolve(); }
return stderr.call(this,chunk,...args);
});
const logSeen=(fragment,from=0)=> {
if(logs.slice(from).some(line=>line.includes(fragment)))return Promise.resolve();
return new Promise(resolve=>waiters.push({fragment,from,resolve}));
};
const waitLog=(fragment,from=0)=>deadline(logSeen(fragment,from),`no log line with "${fragment}"`,waitMs);
let queueWaiters=[];
const queueSeen=(count)=> state.calls.filter(p=>p.includes('/usage/queue')).length>=count?Promise.resolve():new Promise(resolve=>queueWaiters.push({count,resolve}));
const waitQueue=(count)=>deadline(queueSeen(count),`no usage queue read number ${count}`,waitMs);
const answerQueue=res=>{res.end(JSON.stringify(state.queued));state.queued=[];};
const server=http.createServer(async(req,res)=>{
state.calls.push(req.url);
if(req.headers.authorization!=='Bearer p5-r1-made-up-management' && req.url.startsWith('/v8/management/')) {res.writeHead(401);res.end('{}');return;}
if(req.url==='/v8/management/config/access/api-keys') {
if(req.method==='PUT'){let body='';for await(const c of req)body+=c;state.keys=JSON.parse(body);res.end('{"status":"ok"}');}
else res.end(JSON.stringify(state.keys));return;
}
if(req.url==='/v8/management/observability/usage/queue?count=100') {
if(state.hold)state.held.push(res);else answerQueue(res);
const count=state.calls.filter(p=>p.includes('/usage/queue')).length;
for(const waiter of queueWaiters.filter(w=>count>=w.count))waiter.resolve();
queueWaiters=queueWaiters.filter(w=>count<w.count);return;
}
res.writeHead(state.keys.includes(req.headers.authorization?.slice(7))?200:401);res.end('{}');
});
await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
let bus=null,startPromise=null,closePromise=null;
const start=()=>startPromise??=(startBroker({dataRoot:data,...(orgMode ? {instanceRoot:root} : {}),businesses:{demo:{id:'demo',human:'jason',plugins:doc.plugins,arbiters:{technical:'chief',delivery:'chief'},roles:{chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery'], crossRole: [] } }, coder:{definition:'coder',authority:{withinRole:[],crossRole:[]}}}}},
organization:{dir:config,rolesDir,system:systemFor(config)},proxy:{port:server.address().port,binary:'/fixture-unused'}}).then(value=>(bus=value)));
const release=(fail=false)=>{state.hold=false;for(const res of state.held.splice(0)){if(res.destroyed)continue;if(fail){res.writeHead(503);res.end('{}');}else answerQueue(res);}};
const close=()=>bus?(closePromise??=bus.close()):Promise.resolve();
t.after(async()=>{release();await startPromise?.catch(()=>{});await close();server.closeAllConnections();await new Promise(r=>server.close(r));rmSync(root,{recursive:true,force:true});});
return {root,data,config,state,logs,own,other,start,waitLog,waitQueue,release,close,
settleInitial:()=>deadline(Promise.race([logSeen('proxy-usage-read-failed'),logSeen('proxy.usage.reconcile')]),'no proxy-usage-read-failed or proxy.usage.reconcile log line',waitMs),
get bus(){return bus;},queueCalls:()=>state.calls.filter(p=>p.includes('/usage/queue')).length,
human:()=>bus.broker.bindHuman({business:'demo',human:'jason',via:'cli',outsideAgent:true}),
async pollSettledAfterTick(t){const from=logs.length,next=state.calls.filter(p=>p.includes('/usage/queue')).length+1;t.mock.timers.tick(1000);await deadline(Promise.race([queueSeen(next),logSeen('proxy-usage-read-failed',from)]).then(()=>new Promise(resolve=>realSetImmediate(resolve))),`no usage queue read number ${next} or proxy-usage-read-failed log line`,waitMs);},
};
}