diff --git a/packages/bus/tests/p5-background.test.mjs b/packages/bus/tests/p5-background.test.mjs new file mode 100644 index 0000000000000000000000000000000000000000..bb51ad3527280f0db0449c27eb42474dd8b9e894 --- /dev/null +++ b/packages/bus/tests/p5-background.test.mjs @@ -0,0 +1,51 @@ +// Prepared after Mos1971 STOP. These controls have NOT been executed locally. +// Only fake loopback HTTP, explicit event barriers and virtual existing timers. +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createHash } from 'node:crypto'; +import { mkdirSync, writeFileSync } from 'node:fs'; +import { join } from 'node:path'; +import { startTimeOf } from '../../seat/src/proc.mjs'; +import { telemetryFixture } from './p5-telemetry-fixture.mjs'; +async function nativeTurn(f) { + const model=await f.bus.modelPreflight({business:'demo',role:'coder'}); + const keyId=createHash('sha256').update(model.key).digest('hex').slice(0,12),dir=join(f.root,'native-transcript');mkdirSync(dir); + const {cap}=f.bus.bindLaunch({business:'demo',role:'coder',run:'held-poll-native',harness:'pi',modelKeyId:keyId,transcript:dir, + pid:process.pid,startTime:startTimeOf(process.pid)}); + f.bus.broker.request(cap,{verb:'role.claim'}); + assert.deepEqual(await f.bus.mayLaunch({business:'demo',instance:'coder',provider:'fixture',model:'fake'}),{allow:true}); + const human=f.human(),{id}=f.bus.broker.request(human,{verb:'message.send',args:{to:'coder',body:'native work while optional queue is held'}}); + f.bus.broker.request(cap,{verb:'message.receive'}); + await f.bus.broker.request(cap,{verb:'usage.begin',args:{turn:id}}); + writeFileSync(join(dir,'native.jsonl'),JSON.stringify({type:'message',id:'native',message:{role:'assistant',usage:{input:2,output:1,cacheRead:0,cacheWrite:0}}})+'\n'); + await f.bus.broker.request(cap,{verb:'usage.end',args:{turn:id}}); + const view=f.bus.broker.request(human,{verb:'usage'}); + assert.equal(view.total.input,2);assert.equal(view.byKey[0].modelKeyId,keyId); + assert.deepEqual(f.bus.broker.request(cap,{verb:'message.receive'}),[]); +} +for(const fail of [false,true])test(`P5 R1 held first optional poll does not delay native startup or work; ${fail?'failure':'release'} settles safely`,async t=>{ + t.mock.timers.enable({apis:['Date','setInterval'],now:Date.now()}); + const f=await telemetryFixture(t,{hold:true});const started=f.start(); + await f.waitQueue(1);await new Promise(setImmediate); + // Causal first guard: the queue is still held, so a ready runtime cannot + // have depended on its response. No racing timeout or longer budget. + assert.notEqual(f.bus,null,'startBroker must resolve while the first queue response is held'); + await started;assert.equal(f.state.held.length,1); + assert.equal(f.bus.broker.request(f.human(),{verb:'plugins'}).plugins.usage,'cliproxy-queue'); + await nativeTurn(f);assert.equal(f.queueCalls(),1); + t.mock.timers.tick(1000);await new Promise(setImmediate);assert.equal(f.queueCalls(),1,'scheduled ticks share the held first read'); + const from=f.logs.length;f.release(fail); + await f.waitLog(fail?'proxy-usage-read-failed':'proxy.usage.reconcile',from); + assert.equal(f.bus.broker.request(f.human(),{verb:'usage'}).proxy.state,fail?'unavailable':'available'); + await f.close();assert.equal(f.queueCalls(),1); +}); +test('P5 R1 close bounds an outstanding first poll by the unchanged five-second client deadline',async t=>{ + t.mock.timers.enable({apis:['Date','setInterval','setTimeout'],now:Date.now()}); + const f=await telemetryFixture(t,{hold:true});const started=f.start();await f.waitQueue(1);await new Promise(setImmediate); + assert.notEqual(f.bus,null,'native readiness precedes the held optional poll');await started; + let closed=false;const closing=f.close().then(()=>{closed=true;}); + t.mock.timers.tick(4999);await new Promise(setImmediate);assert.equal(closed,false); + t.mock.timers.tick(1);await closing; + assert.equal(closed,true);assert.equal(f.queueCalls(),1); + assert.ok(f.logs.some(line=>line.includes('proxy-usage-read-failed'))); +}); diff --git a/packages/bus/tests/p5-identity.test.mjs b/packages/bus/tests/p5-identity.test.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4ee111f7c9ec75dbae24c184c3310b71973fc7c2 --- /dev/null +++ b/packages/bus/tests/p5-identity.test.mjs @@ -0,0 +1,38 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { telemetryFixture } from './p5-telemetry-fixture.mjs'; +for(const foreign of [true,false])test(`P5 R1 boot identity ${foreign?'refusal prevents queue consumption':'matching sentinel permits telemetry without an agent key'}`,async t=>{ + t.mock.timers.enable({apis:['Date','setInterval'],now:Date.now()}); + const f=await telemetryFixture(t,{foreign});await f.start();await f.settleInitial(); + const human=f.human();assert.equal(f.bus.broker.request(human,{verb:'plugins'}).plugins.usage,'cliproxy-queue'); + if(foreign){ + await assert.rejects(f.bus.modelPreflight({business:'demo',role:'coder'}),{code:'proxy-open'}); + assert.equal(f.queueCalls(),0);assert.equal(f.state.queued.length,1); + await f.pollSettledAfterTick(t);assert.equal(f.queueCalls(),0);assert.equal(f.state.queued.length,1); + assert.equal(f.bus.broker.request(human,{verb:'usage'}).proxy.state,'unavailable'); + }else{ + assert.equal(f.queueCalls(),1);assert.equal(f.state.queued.length,0); + assert.equal(f.bus.broker.request(human,{verb:'usage'}).proxy.state,'available'); + assert.equal(f.bus.credentials.status().some(r=>r.service==='model'&&r.keyId),false); + } +}); +test('P5 R1 later sentinel refusal fences every subsequent queue poll while preserving human control',async t=>{ + t.mock.timers.enable({apis:['Date','setInterval'],now:Date.now()}); + const f=await telemetryFixture(t);await f.start();await f.settleInitial();assert.equal(f.queueCalls(),1); + f.state.keys=[f.other]; + await assert.rejects(f.bus.modelPreflight({business:'demo',role:'coder'}),{code:'proxy-open'}); + await f.pollSettledAfterTick(t);assert.equal(f.queueCalls(),1); + await f.pollSettledAfterTick(t);assert.equal(f.queueCalls(),1); + const human=f.human();assert.equal(f.bus.broker.request(human,{verb:'plugins'}).plugins.usage,'cliproxy-queue'); + assert.equal(f.bus.broker.request(human,{verb:'usage'}).proxy.state,'unavailable'); +}); + +test('P5 R1 every drain verifies fresh sentinel before consuming a changed listener',async t=>{ + t.mock.timers.enable({apis:['Date','setInterval'],now:Date.now()}); + const f=await telemetryFixture(t);await f.start();await f.settleInitial();assert.equal(f.queueCalls(),1); + f.state.keys=[f.other];await f.pollSettledAfterTick(t);assert.equal(f.queueCalls(),1); + await assert.rejects(f.bus.modelPreflight({business:'demo',role:'coder'}),{code:'proxy-open'}); + const lists=f.state.calls.filter(p=>p==='/v8/management/config/access/api-keys').length; + f.state.keys=[f.own];await f.pollSettledAfterTick(t);assert.equal(f.queueCalls(),1); + assert.equal(f.state.calls.filter(p=>p==='/v8/management/config/access/api-keys').length,lists,'no retry around sticky identity refusal'); +}); diff --git a/packages/bus/tests/p5-key-compatibility.test.mjs b/packages/bus/tests/p5-key-compatibility.test.mjs new file mode 100644 index 0000000000000000000000000000000000000000..331032ecb48644587057a9ec4799e69d5fa3cdc8 --- /dev/null +++ b/packages/bus/tests/p5-key-compatibility.test.mjs @@ -0,0 +1,68 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { mkdtempSync, rmSync, readFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import { Store } from '../src/store.mjs'; +import { createLimits, modelUsageKey } from '../src/limits.mjs'; +import * as token from '../../plugins/limit-check/token-limit/index.mjs'; +import * as daily from '../../plugins/limit-check/daily-quota/index.mjs'; +import { launchSettings } from '../../business/src/launch-settings.mjs'; +import { businessDoc, rolesCopy, writeJson, systemFor } from '../../business/tests/helpers.mjs'; +const key='abcdefabcdef',other='012345abcdef',since='2026-01-01T00:00:00.000Z'; +const quota={limit:10,since,reset:'00:00',timeZone:'UTC'}; +const native={at:'2026-10-26T12:00:00.000Z',run:'legacy-run',turn:'turn',account:key,modelKeyId:other,status:'known',input:10,output:0,cacheWrite:0,cacheRead:0}; +test('P5 R1 plain twelve-hex account leaves retain matching and original account report even with another model ID',()=>{ + const a={limits:{tokens:{keys:{[key]:{limit:10,since}}}},subject:{account:key,modelKeyId:other},records:[native]}; + assert.equal(token.mayLaunch(a).allow,false);assert.equal(token.mustStop(a).stop,true); + assert.equal(token.report(a)[0].count,10);assert.deepEqual(token.report(a)[0].path,['tokens','keys',key]); + assert.equal(token.mayLaunch({...a,records:[{...native,input:9}]}).allow,true); + assert.deepEqual(daily.report({...a,now:native.at}),[]); +}); +for(const proxy of [false,true])test(`P5 R1 legacy account core lookup stays independent of ${proxy?'unrelated proxy metadata':'missing proxy metadata'}`,async t=>{ + const root=mkdtempSync(join(tmpdir(),'p5-legacy-')),store=new Store(root);t.after(()=>{store.close();rmSync(root,{recursive:true,force:true});}); + let lookups=0; + const b={launch:{account:{name:key,credential:'FAKE_TOKEN_NAME'},limits:{tokens:{keys:{[key]:{limit:10,since}}}}},plugins:{'limit-check':['token-limit']}}; + const limits=createLimits({store,read:()=>b,log:()=>{},keyForSubject:(...args)=>{lookups++;return proxy?modelUsageKey([{service:'model',instance:'demo/coder',keyId:other,retiring:[]}],new Map(),'demo',args[1]):null;}}); + assert.deepEqual(await limits.mayLaunch('demo',{instance:'coder',account:key}),{allow:true}); + store.run(`INSERT INTO usage_records(at,business,run,instance,account,turn,source,phase,status,cursor,input,output,cache_write,cache_read) + VALUES (?,'demo','legacy-run','coder',?,'turn','transcript','end','known',?,10,0,0,0)`,native.at,key,JSON.stringify({modelKeyId:other})); + const hit={path:['tokens','keys',key],limit:10,count:10,unknownTurns:0}; + assert.deepEqual(await limits.mayLaunch('demo',{instance:'coder',account:key}),{allow:false,check:'token-limit',hit}); + assert.deepEqual(await limits.mustStop('demo',{instance:'coder',account:key}),{stop:true,check:'token-limit',hit}); + assert.equal(limits.report('demo')[0].count,10);assert.equal(lookups,0); +}); +for(const leaf of [{limit:0,since},quota])test(`P5 R1 empty checks bypass model metadata for ${leaf.reset?'daily model':'legacy hex account'} leaves`,async t=>{ + const root=mkdtempSync(join(tmpdir(),'p5-no-checks-')),store=new Store(root);t.after(()=>{store.close();rmSync(root,{recursive:true,force:true});}); + let lookups=0;const limits=createLimits({store,read:()=>({plugins:{'limit-check':[]},launch:{limits:{tokens:{keys:{[key]:leaf}}}}}),log:()=>{},keyForSubject:()=>{lookups++;throw Error('MUST-NOT-LOOK-UP');}}); + assert.deepEqual(await limits.mayLaunch('demo',{instance:'coder',account:key}),{allow:true}); + assert.deepEqual(await limits.mustStop('demo',{instance:'coder',account:key}),{stop:false});assert.equal(lookups,0); +}); +test('P5 R1 legacy hex account chief resets stay allowed; daily model old/new/removal/reset transitions stay human-only',t=>{ + const root=mkdtempSync(join(tmpdir(),'p5-fence-'));t.after(()=>rmSync(root,{recursive:true,force:true})); + const rolesDir=rolesCopy(root),doc=businessDoc(root,'demo'),file=join(root,'businesses/demo.json'); + doc.launch.account={name:key,credential:'FAKE_TOKEN_NAME'};doc.launch.limits={tokens:{keys:{[key]:{limit:10,since}}}};writeJson(file,doc); + let now='2026-10-26T12:00:00.000Z';const settings=launchSettings({dir:root,rolesDir,system:systemFor(root),now:()=>now});let v=settings.read('demo'); + v=settings.set('demo',{revision:v.revision,reset:[['tokens','keys',key]]},'chief'); + assert.equal(JSON.parse(readFileSync(file,'utf8')).launch.limits.tokens.keys[key].since,now); + const dailyLeaf={limit:10,reset:'00:00',timeZone:'UTC'}; + assert.throws(()=>settings.set('demo',{revision:v.revision,limits:{tokens:{keys:{[key]:dailyLeaf}}}},'chief'),{code:'organization-model-quota-human-only'}); + v=settings.set('demo',{revision:v.revision,limits:{tokens:{keys:{[key]:dailyLeaf}}}},'jason');now='2026-10-26T13:00:00.000Z'; + for(const args of [{reset:[['tokens','keys',key]]},{limits:{}},{limits:{tokens:{keys:{[key]:{limit:10}}}}}]) + assert.throws(()=>settings.set('demo',{revision:v.revision,...args},'chief'),{code:'organization-model-quota-human-only'}); + v=settings.set('demo',{revision:v.revision,limits:{tokens:{keys:{[key]:{limit:10}}}}},'jason'); + v=settings.set('demo',{revision:v.revision,reset:[['tokens','keys',key]]},'chief'); + assert.equal(JSON.parse(readFileSync(file,'utf8')).launch.limits.tokens.keys[key].since,now); +}); + +test('P5 R1 daily model matching/report is separate from legacy account and schema refuses partial or invalid daily shapes',async()=>{ + const {checkTokenLimits}=await import('../../business/src/launch.mjs'); + assert.deepEqual(checkTokenLimits({keys:{[key]:quota}}).keys[key],quota); + const args={limits:{tokens:{keys:{[key]:quota}}},records:[native],subject:{account:key,modelKeyId:other},now:native.at}; + assert.deepEqual(token.report(args),[]); + assert.equal(daily.mayLaunch(args).allow,true);assert.equal(daily.report(args)[0].count,0); + const owned={...args,subject:{account:'other-account',modelKeyId:key},records:[{...native,account:'other-account',modelKeyId:key}]}; + assert.equal(daily.mayLaunch(owned).allow,false);assert.equal(daily.mustStop(owned).stop,true);assert.equal(daily.report(owned)[0].count,10); + for(const leaf of [{...quota,reset:'25:00'},{...quota,timeZone:'Mars/Phobos'},{limit:10,since,reset:'00:00'},{limit:10,since,timeZone:'UTC'}]) + assert.throws(()=>checkTokenLimits({keys:{[key]:leaf}})); +}); diff --git a/packages/bus/tests/p5-telemetry-fixture.mjs b/packages/bus/tests/p5-telemetry-fixture.mjs new file mode 100644 index 0000000000000000000000000000000000000000..99390f7d565a7d7db5344b574bc5a8623d5fa073 --- /dev/null +++ b/packages/bus/tests/p5-telemetry-fixture.mjs @@ -0,0 +1,66 @@ +// 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 '../../business/tests/helpers.mjs'; +export async function telemetryFixture(t, { foreign = false, hold = 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 waitLog=(fragment,from=0)=> { + if(logs.slice(from).some(line=>line.includes(fragment)))return Promise.resolve(); + return new Promise(resolve=>waiters.push({fragment,from,resolve})); + }; + let queueWaiters=[]; + const waitQueue=(count)=> state.calls.filter(p=>p.includes('/usage/queue')).length>=count?Promise.resolve():new Promise(resolve=>queueWaiters.push({count,resolve})); + 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=>countserver.listen(0,'127.0.0.1',resolve)); + let bus=null,startPromise=null,closePromise=null; + const start=()=>startPromise??=(startBroker({dataRoot:data,businesses:{demo:{id:'demo',human:'jason',plugins:doc.plugins,arbiters:{technical:'coder',delivery:'coder'},roles:{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:()=>Promise.race([waitLog('proxy-usage-read-failed'),waitLog('proxy.usage.reconcile')]), + 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 Promise.race([waitQueue(next),waitLog('proxy-usage-read-failed',from)]);await new Promise(setImmediate);}, + }; +}