@jc_stack/ez-agents 0.1.0-beta.47 → 0.1.0-beta.48

package/test/tasks.test.ts

@@ -15,16 +15,17 @@ import { requireOwnerExecution } from '../src/execution-authority.js'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
 
-async function fixture(t: test.TestContext, channelOwner = false) {
+async function fixture(t: test.TestContext, channelOwner = false, speech?: (text:string) => Promise<{buffer:Buffer;mimeType:string}>) {
   const dir = await mkdtemp('/tmp/ez-task-test-'), socket = join(dir, 's.sock')
   let accountId = 'account-a', events: SourceEvent[] = [], uncertain = false
   const sends: any[] = [], watches: any[] = []
   const server = createServer(async (req, res) => {
     let text = ''; for await (const chunk of req) text += chunk
     const { command, args } = JSON.parse(text)
-    const data = command === 'events-head' ? { cursor: 0, accountId, taskProtocol: 'message-v1', persistentWatch: true, wildcardWatch: true }
+    const data = command === 'events-head' ? { cursor: 0, accountId, taskProtocol: 'message-v1', persistentWatch: true, wildcardWatch: true, taskVoice: true }
       : command === 'task-watch' ? (watches.push(args), { watching: args.conversationId })
       : command === 'events-check' ? { events: events.filter(e => args.ids.includes(e.id)) }
+      : command === 'task-document' ? {name:'shop.txt',data:Buffer.from('Shop opens at 7am.').toString('base64'),sha256:createHash('sha256').update('Shop opens at 7am.').digest('hex')}
       : command === 'task-send' ? (sends.push(args), { ...args, state: uncertain ? 'uncertain' : 'accepted', receiptId: 'provider-1' }) : {}
     res.end(JSON.stringify({ ok: true, data }))
   })
@@ -35,7 +36,7 @@ async function fixture(t: test.TestContext, channelOwner = false) {
     await runs.create({ id: 'owner', ownerId: ownerId(owner), ownerEpoch: ownerEpoch(owner), texts: ['Own this conversation'] })
     await runs.patch('owner', { status: 'running' })
   } else await ownerRun(dir, 'owner')
-  const control = new ControlStore(dir, 900000), sources = new EventSources(dir), runs = new RunStore(dir), tasks = new Tasks(dir)
+  const control = new ControlStore(dir, 900000), sources = new EventSources(dir), runs = new RunStore(dir), tasks = new Tasks(dir,speech)
   await sources.register('generic', socket, (await control.status()).owner!)
   t.after(async () => { server.closeAllConnections(); await new Promise<void>(r => server.close(() => r())); await rm(dir, { recursive: true, force: true }) })
   async function proposal() {
@@ -247,7 +248,7 @@ test('approved initial task crosses the real host file client and uses a fresh r
   const { isHostRunId } = await import('../src/host-executor-protocol.js')
   const f = await fixture(t), { run } = await f.activate()
   assert.ok(isHostRunId(run.id))
-  await writeFile(join(f.dir, 'codex'), `#!${process.execPath}\nif(process.argv[2]==='--version')console.log('codex-cli 0.160.0');else if(process.argv[2]==='debug')console.log(JSON.stringify({models:[{slug:'fixture',tool_mode:'code_mode_only',apply_patch_tool_type:'freeform',multi_agent_version:'v2'}]}));else console.log(JSON.stringify({cwd:process.cwd(),args:process.argv.slice(2),control:process.env.EZ_CONTROL_DIR}));`, { mode: 0o700 })
+  await writeFile(join(f.dir, 'codex'), `#!${process.execPath}\nif(process.argv[2]==='--version')console.log('codex-cli 0.160.1');else if(process.argv[2]==='debug')console.log(JSON.stringify({models:[{slug:'fixture',tool_mode:'code_mode_only',apply_patch_tool_type:'freeform',multi_agent_version:'v2'}]}));else console.log(JSON.stringify({cwd:process.cwd(),args:process.argv.slice(2),control:process.env.EZ_CONTROL_DIR}));`, { mode: 0o700 })
   const priorPath = process.env.PATH
   process.env.PATH = `${f.dir}:${priorPath}`
   const abort = new AbortController(), host = serveHostExecutor({ cli: 'codex', agents: [{ name: 'test', workspace: f.dir, controlDir: f.dir, binDir: f.dir }] }, abort.signal)
@@ -341,3 +342,95 @@ test('public grants enforce persisted hourly and cumulative admission budgets',a
   assert.equal(await f.tasks.admitPublic(proposal.id),'revoked')
   assert.equal((await f.tasks.get(proposal.id))?.state,'revoked')
 })
+
+
+test('voice reuses task send authority and receipt keys, rechecks the account after synthesis, and never falls back to text', async t => {
+  let generated = 0, changed = false
+  let changeAccount: (value:string) => void
+  const f = await fixture(t,false,async text => {
+    generated++; assert.equal(text, 'Spoken fixture')
+    if(changed)changeAccount('replaced')
+    return {buffer:Buffer.from('OggSfixture OpusHead'),mimeType:'audio/ogg'}
+  })
+  changeAccount = f.account
+  const {run} = await f.activate()
+  const sent = await f.tasks.workerCall(run.id,'send',{text:'Spoken fixture',key:'spoken',voice:true})
+  assert.ok('state' in sent);assert.equal(sent.state,'accepted');assert.equal(generated,1);assert.equal(f.sends.length,1)
+  assert.equal(Buffer.from(f.sends[0].audio.data,'base64').toString(),'OggSfixture OpusHead')
+  await f.tasks.workerCall(run.id,'send',{text:'Spoken fixture',key:'spoken',voice:true})
+  assert.equal(generated,1);assert.equal(f.sends.length,1)
+  await assert.rejects(f.tasks.workerCall(run.id,'send',{text:'Spoken fixture',key:'spoken'}), /different text/)
+  changed=true
+  assert.equal((await f.tasks.workerCall(run.id,'send',{text:'Spoken fixture',key:'changed',voice:true}) as {state:string}).state,'uncertain')
+  assert.equal(f.sends.length,1)
+})
+
+test('voice generation failure is a definite non-send: no text, no stored operation, same key retryable', async t => {
+  let generated=0
+  const f=await fixture(t,false,async () => { if(++generated===1)throw new Error('provider failed'); return {buffer:Buffer.from('OggSfixture OpusHead'),mimeType:'audio/ogg'} })
+  const {run, taskId}=await f.activate()
+  await assert.rejects(f.tasks.workerCall(run.id,'send',{text:'Spoken fixture',key:'failed',voice:true}),/provider failed/)
+  assert.equal(f.sends.length,0);assert.equal(Object.hasOwn((await f.tasks.get(taskId))!.operations,'failed'),false)
+  assert.equal((await f.tasks.workerCall(run.id,'send',{text:'Spoken fixture',key:'failed',voice:true}) as {state:string}).state,'accepted')
+  assert.equal(generated,2);assert.equal(f.sends.length,1)
+})
+
+
+test('a cancelled worker cannot dispatch a voice generated after stop', async t => {
+  let stop: () => Promise<unknown>
+  const f=await fixture(t,false,async () => { await stop(); return {buffer:Buffer.from('OggSfixture OpusHead'),mimeType:'audio/ogg'} })
+  const {run}=await f.activate();stop=()=>f.runs.patch(run.id,{status:'cancelled'})
+  assert.equal((await f.tasks.workerCall(run.id,'send',{text:'Spoken fixture',key:'stopped',voice:true}) as {state:string}).state,'uncertain')
+  assert.equal(f.sends.length,0)
+})
+
+test('incoming documents use shared staging and never expose another event or owner path', async t => {
+ const f=await fixture(t), {taskId}=await f.activate(), task=(await f.tasks.get(taskId))!
+ const row={id:'1',conversationId:'contact-a',receivedAt:Date.now(),text:'Document attached'};f.rows([row])
+ const run=await f.runs.create({id:'event_document',taskId,chatId:101,telegramUserId:101,texts:[],external:{sourceId:'generic',bindingId:task.bindingId,eventIds:['1']}})
+ await f.runs.patch(run.id,{status:'running'})
+ const document:any=await f.tasks.workerCall(run.id,'read_attachment',{incomingId:'1'})
+ assert.equal(document.text,'Shop opens at 7am.');assert.equal(document.name,'shop.txt');assert.equal(document.type,'text')
+ await assert.rejects(f.tasks.workerCall(run.id,'read_attachment',{incomingId:'2'}),/outside/)
+ await assert.rejects(f.tasks.workerCall(run.id,'read_attachment',{incomingId:'/etc/passwd'}),/outside/)
+ f.rows([{...row,conversationId:'contact-b'}]);await assert.rejects(f.tasks.workerCall(run.id,'read_attachment',{incomingId:'1'}),/correspondence/)
+})
+
+test('explicit application launch continues restricted task; cross-task, owner mode, revocation and replay changes fail closed',async t=>{
+  const {ApplicationBindings,ApplicationChannel}=await import('../src/application-channel.js')
+  const {initialPreset}=await import('../src/ai.js')
+  const f=await fixture(t), {taskId,run}=await f.activate(), owner=(await f.control.status()).owner!
+  const bindings=new ApplicationBindings(f.dir), binding=(await bindings.register('browser','x'.repeat(48),owner))!
+  const token='a'.repeat(64),ticketHash=createHash('sha256').update(token).digest('hex')
+  await assert.rejects(f.tasks.workerCall(run.id,'application_launch',{application:'browser',ticketHash}),/not authorized/)
+  await bindings.taskLaunch('browser',{command:'fixture',args:['launch','--task'],tasks:[taskId]})
+  const grant=await f.tasks.workerCall(run.id,'application_launch',{application:'browser',ticketHash}) as {taskId:string;expiresAt:number}
+  assert.equal(grant.taskId,taskId)
+  assert(!(await readFile(join(f.dir,'task-applications',ticketHash+'.json'),'utf8')).includes(token))
+  const admission=await f.tasks.authorizeApplicationLaunch(run.id,ticketHash)
+  assert.deepEqual(admission.launch,{command:'fixture',args:['launch','--task'],tasks:[taskId]})
+  await assert.rejects(f.tasks.authorizeApplicationLaunch('owner',ticketHash))
+  const app=new ApplicationChannel({controlDir:f.dir,initial:initialPreset('codex'),wake(){},async cancel(){}})
+  const input={requestId:'voice-test',scope:'task:'+taskId,text:'When is the booking?',taskToken:token}
+  await assert.rejects(app.submit(binding.bindingId,{...input,followOwner:true}),/Invalid application task/)
+  await assert.rejects(app.submit(binding.bindingId,{...input,scope:'task:other'}),/scope/)
+  const delegated=await app.submit(binding.bindingId,input)
+  assert.equal(delegated.taskId,taskId);assert.equal(delegated.version,2)
+  assert.equal((await app.submit(binding.bindingId,input)).id,delegated.id)
+  await assert.rejects(app.submit(binding.bindingId,{...input,text:'Changed request'}),/conflicts/)
+  await f.runs.patch(delegated.id,{status:'running'})
+  const context=await f.tasks.workerCall(delegated.id,'context',{}) as {notes:string[];request:string;context:string}
+  assert.match(context.context,/Two people/);assert.equal(context.request,input.text)
+  await f.tasks.workerCall(delegated.id,'note',{text:'Discussion-only voice result'})
+  const reply=await f.tasks.workerCall(delegated.id,'send',{key:'answer',text:'7pm'}) as {receipt:{queued:string}}
+  assert.equal(f.sends.length,0)
+  const outbox=(await f.runs.pendingOutbox()).find(x=>x.id===reply.receipt.queued)!
+  await app.deliver(delegated,outbox)
+  assert.deepEqual((await app.snapshot(binding.bindingId,delegated.id)).messages.map(m=>m.text),['7pm'])
+  const other=(await bindings.register('other','y'.repeat(48),owner))!
+  await bindings.taskLaunch('other',{command:'fixture',args:['launch'],tasks:'all'})
+  await assert.rejects(app.submit(other.bindingId,{...input,requestId:'other'}),/revoked/)
+  await bindings.taskLaunch('browser',null)
+  await assert.rejects(f.tasks.authorize(delegated),/revoked/)
+  await assert.rejects(app.snapshot(binding.bindingId,delegated.id),/revoked/)
+})

package/test/updates.test.mjs

@@ -114,13 +114,16 @@ test('root preparation leaves private plugin updates readable by the installer',
  await exec('setpriv',['--reuid=20001','--regid=20002','--clear-groups','--no-new-privs',process.execPath,'-e',script]);
 });
 function runtime(f,{fail,stopped=false,buildArgs={CODEX_CLI_VERSION:'0.156.1'},latest='0.160.0'}={}) {
- const calls=[];let failed=false;
+ const calls=[];let failed=false,brokerImage='sha256:'+'a'.repeat(64);
  const execute=async(command,args,opts)=>{
   calls.push([command,...args]);if(args.includes('view'))return JSON.stringify(latest);if(fail&&!failed&&fail(command,args)){failed=true;throw Error('Synthetic failure');}
   if(args.at(-1)==='--version')return '10.30.3';
   if(args.includes('config'))return JSON.stringify({services:{relay:{build:{args:buildArgs}}}});
-  if(args.includes('ps'))return stopped?'':'container-id';
-  if(args[0]==='inspect')return 'sha256:'+'a'.repeat(64);
+  if(args.includes('ps'))return stopped?'':'a'.repeat(64);
+  if(args.some(arg=>arg.includes('EZ_BROKER_STRUCTURAL_READINESS_FAILED'))) {const [hostSha256,registrySha256,configSha256]=args.slice(-3);return JSON.stringify({version:1,ready:true,hostSha256,registrySha256,configSha256,plugins:[]});}
+  if(args[0]==='image'&&args[1]==='inspect')return 'sha256:'+'b'.repeat(64);
+  if(args.includes('--force-recreate'))brokerImage=(await fs.readFile(args[args.lastIndexOf('--env-file')+1],'utf8')).trim().split('=')[1];
+  if(args[0]==='inspect')return brokerImage;
   if(args[0]==='volume'&&args[1]==='ls')return 'existing';
   if(args[0]==='volume')return JSON.stringify([{Name:args[2]}]);
   if(args[0]==='run')await fs.writeFile(opts.outputFile,'retained-private-state',{mode:0o600});
@@ -384,22 +387,55 @@ test('plugin updates register additive command routes on an unchanged deployment
  const dispatch=await prepareCommand(f.home,'query',[]);assert.deepEqual(dispatch.argv.slice(-4),['node','sample','/app/bin/example.mjs','query']);
  assert(r.calls.some(call=>call.includes('up')));
 });
-test('isolated plugin replacement refreshes broker version inventory after registry activation',async t=>{
+test('isolated plugin replacement recreates only the pinned broker and verifies activation and rollback',async t=>{
  const f=await fixture(t,'plugin');
  await fs.appendFile(path.join(f.config.deploymentDir,'docker.env'),'EZ_EXECUTOR_TRANSPORT=local\n');
  const job=await queued(f),r=runtime(f),execute=r.execute;
  let observed;
  r.execute=async(command,args,options)=>{
-  if(args.includes('restart')&&args.at(-1)==='plugin-broker') observed=(await read(path.join(f.home,'registry.json'))).plugins.sample.manifest.version;
+  if(args.some(arg=>arg.includes('EZ_BROKER_STRUCTURAL_READINESS_FAILED'))) observed=(await read(path.join(f.home,'registry.json'))).plugins.sample.manifest.version;
+  if(args.includes('--force-recreate')) {
+   assert.equal(args.at(-1),'plugin-broker');
+   for(const flag of ['--no-deps','--no-build','--wait'])assert(args.includes(flag));
+   assert.equal(args[args.indexOf('--pull')+1],'never');
+   assert.equal(await fs.readFile(args[args.lastIndexOf('--env-file')+1],'utf8'),'EZ_RELAY_IMAGE=sha256:'+ 'a'.repeat(64)+'\n');
+  }
   return execute(command,args,options);
  };
  assert.equal((await perform(f.home,job,r)).status,'completed');
- assert.equal(observed,'0.1.1');
- assert.equal(r.calls.filter(call=>call.includes('restart')).length,1);
+ assert.equal(observed,'0.1.1');assert.equal(job.brokerReadiness.ready,true);
  const interrupted=await read(path.join(jobPath(f.home,job.id),'job.json'));interrupted.status='applying';
  assert.equal((await perform(f.home,interrupted,r)).status,'rolled-back');
- assert.equal(observed,'0.1.0');
- assert.equal(r.calls.filter(call=>call.includes('restart')).length,2);
+ assert.equal(observed,'0.1.0');assert.equal(interrupted.rollbackBrokerReadiness.ready,true);
+ assert.equal(r.calls.filter(call=>call.includes('--force-recreate')).length,2);
+ assert(!r.calls.some(call=>call.includes('restart')||call[0]==='stopHost'));
+});
+for(const boundary of ['recreate','probe','readback'])test(`isolated broker ${boundary} failure cannot complete an update`,async t=>{
+ const f=await fixture(t,'plugin');await fs.appendFile(path.join(f.config.deploymentDir,'docker.env'),'EZ_EXECUTOR_TRANSPORT=local\n');
+ const job=await queued(f),r=runtime(f),base=r.execute;
+ r.execute=async(c,a,o)=>{
+  if(boundary==='recreate'&&a.includes('--force-recreate')||boundary==='probe'&&a.some(arg=>arg.includes('EZ_BROKER_STRUCTURAL_READINESS_FAILED')))throw Error('Synthetic broker failure');
+  if(boundary==='readback'&&a.some(arg=>arg.includes('EZ_BROKER_STRUCTURAL_READINESS_FAILED')))return JSON.stringify({version:1,ready:true,hostSha256:'0'.repeat(64)});
+  return base(c,a,o);
+ };
+ const result=await perform(f.home,job,r);
+ assert.equal(result.status,'recovery-required');assert(result.error);assert(result.recoveryError);
+ assert.equal((await read(path.join(f.home,'registry.json'))).plugins.sample.manifest.version,'0.1.0');
+});
+test('main isolated activation and retained-relay rollback also refresh the broker',async t=>{
+ const f=await fixture(t);await fs.appendFile(path.join(f.config.deploymentDir,'docker.env'),'EZ_EXECUTOR_TRANSPORT=local\n');
+ const job=await queued(f),r=runtime(f);
+ assert.equal((await perform(f.home,job,r)).status,'completed');assert.equal(job.brokerReadiness.ready,true);
+ const base=r.execute;r.execute=async(c,a,o)=>a[0]==='inspect'&&a.includes('{{json .}}')?JSON.stringify({Image:'sha256:'+'a'.repeat(64),State:{Running:true,Health:{Status:'healthy'}}}):base(c,a,o);
+ const interrupted=await read(path.join(jobPath(f.home,job.id),'job.json'));interrupted.status='applying';
+ assert.equal((await perform(f.home,interrupted,r)).status,'rolled-back');
+ assert.equal(interrupted.rollbackBrokerReadiness.ready,true);
+ assert.equal(r.calls.filter(call=>call.includes('--force-recreate')).length,2);
+ assert.equal(r.calls.filter(call=>call.includes('up')&&call.at(-1)==='relay').length,1);
+});
+test('host-capable updates never inspect, recreate or probe an isolated broker',async t=>{
+ const f=await fixture(t,'plugin'),r=runtime(f);assert.equal((await perform(f.home,await queued(f),r)).status,'completed');
+ assert(!r.calls.some(call=>call.includes('plugin-broker')||call.some(arg=>arg.includes('EZ_BROKER_STRUCTURAL_READINESS_FAILED'))));
 });
 test('plugin update preserves a created but never running service as stopped',async t=>{
  const f=await fixture(t,'plugin'),job=await queued(f),r=runtime(f),execute=r.execute;