@jc_stack/ez-agents 0.1.0-beta.12

package/test/intake-relay.test.ts

@@ -0,0 +1,337 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+import type { Update } from 'grammy/types'
+import { createRelay } from '../src/index.js'
+import { ControlStore } from '../src/control-state.js'
+import { RunStore } from '../src/runs.js'
+import { InboxStore } from '../src/inbox.js'
+import { ApprovalStore } from '../src/approval.js'
+import { packageVersion } from '../src/version.js'
+
+const message = (id: number, text = 'hello'): Update => ({
+  update_id: id,
+  message: {
+    message_id: id,
+    date: 0,
+    text,
+    from: { id: 101, is_bot: false, first_name: 'Fixture' },
+    chat: { id: 101, type: 'private', first_name: 'Fixture' },
+  },
+})
+const fixture = async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-intake-relay-'))
+  const launched: string[][] = []
+  const replies: string[] = []
+  const keyboards: { text: string; callback_data: string }[][][] = []
+  const children: ReturnType<typeof spawn>[] = []
+  const config = {
+    controlDir: dir,
+    workspace: dir,
+    pairingTtlMs: 1000,
+    executorTimeoutMs: 1000,
+    executorCli: 'grok' as const,
+    telegramBotToken: 'fixture',
+    geminiApiKey: 'fixture',
+  }
+  const make = () => {
+    const relay = createRelay(config, async (texts) => {
+      launched.push(texts)
+      const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 50)'])
+      children.push(child)
+      await once(child, 'spawn')
+      return { child, cleanup: async () => {}, stdout: '' }
+    })
+    relay.bot.botInfo = {
+      id: 999,
+      is_bot: true,
+      first_name: 'Fixture',
+      username: 'fixture_bot',
+    } as typeof relay.bot.botInfo
+    relay.bot.api.config.use(async (_previous, method, payload) => {
+      if (method === 'sendMessage') replies.push((payload as { text: string }).text)
+      const keyboard = (payload as { reply_markup?: { inline_keyboard?: { text: string; callback_data: string }[][] } }).reply_markup?.inline_keyboard
+      if (keyboard) keyboards.push(keyboard)
+      return {
+        ok: true,
+        result: method === 'getFile' ? { file_path: 'fixture.ogg' } : { message_id: 42 },
+      } as never
+    })
+    return relay
+  }
+  const control = new ControlStore(dir, 1000)
+  await control.requestPairing(101, 101)
+  await control.approveOwner(101)
+  let relay = make()
+  return {
+    dir,
+    launched,
+    replies,
+    keyboards,
+    get relay() {
+      return relay
+    },
+    async restart() {
+      await relay.stop()
+      relay = make()
+    },
+    async close() {
+      await relay.stop()
+      await relay.drainInbox()
+      for (const child of children) {
+        if (child.exitCode === null && child.signalCode === null) await once(child, 'close')
+      }
+      // Completion bookkeeping runs asynchronously after the process close event.
+      const runs = new RunStore(dir)
+      for (let i = 0; i < 100 && (await runs.list()).some((r) => r.status === 'running'); i++)
+        await new Promise((resolve) => setTimeout(resolve, 10))
+      await rm(dir, { recursive: true, force: true })
+    },
+  }
+}
+
+test('four-item menu is owner-only; saved AI buttons work and forged/stale buttons cannot change settings', async () => {
+  const f = await fixture()
+  const callback = (id: number, data: string, user = 101): Update => ({
+    update_id: id,
+    callback_query: { id: String(id), chat_instance: 'fixture', data,
+      from: { id: user, first_name: 'Fixture', is_bot: false }, message: message(id).message! },
+  })
+  try {
+    await f.relay.bot.handleUpdate(message(1, '/menu'))
+    assert.deepEqual(f.keyboards.at(-1)!.flat().map((b) => b.text),
+      ['New conversation', 'Choose AI', 'Work status', 'Settings'])
+    await f.relay.bot.handleUpdate(message(2, '/ai'))
+    const pick = f.keyboards.at(-1)!.flat()[0].callback_data
+    const store = new ControlStore(f.dir, 1000)
+    await f.relay.bot.handleUpdate(callback(3, pick, 202))
+    assert.equal(await store.getActiveSession(), null)
+    await f.relay.bot.handleUpdate(callback(4, 'ai:forged'))
+    assert.equal(await store.getActiveSession(), null)
+    await f.relay.bot.handleUpdate(callback(5, pick))
+    assert.ok(await store.getActiveSession())
+    await f.relay.bot.handleUpdate(callback(6, pick))
+    assert.match(f.replies.at(-1)!, /Menu expired/)
+    await f.relay.bot.handleUpdate(message(7, '/settings'))
+    assert.match(f.replies.at(-1)!, /Default for new conversations/)
+    assert.equal(f.launched.length, 0)
+  } finally { await f.close() }
+})
+
+test('new conversation leaves already accepted messages pinned to the old conversation', async () => {
+  const f = await fixture()
+  try {
+    await f.relay.bot.handleUpdate(message(1, 'before'))
+    const store = new ControlStore(f.dir, 1000)
+    const first = (await store.getActiveSession())!.sessionId
+    await f.relay.bot.handleUpdate(message(2, '/new'))
+    await f.relay.bot.handleUpdate(message(3, 'after'))
+    await f.relay.drainInbox(true)
+    const runs = new RunStore(f.dir)
+    assert.equal((await runs.get('tg_1'))!.execution!.sessionId, first)
+    await f.relay.drainInbox(true)
+    assert.notEqual((await runs.get('tg_3'))!.execution!.sessionId, first)
+  } finally { await f.close() }
+})
+
+test('accepted DM survives relay restart and duplicate delivery creates exactly one run', async () => {
+  const f = await fixture()
+  try {
+    await f.relay.bot.handleUpdate(message(1))
+    assert.equal(f.launched.length, 0)
+    await f.restart()
+    await f.relay.bot.handleUpdate(message(1))
+    await f.relay.drainInbox(true)
+    assert.deepEqual(f.launched, [['hello']])
+    await f.relay.bot.handleUpdate(message(1))
+    await f.relay.drainInbox(true)
+    assert.equal((await new RunStore(f.dir).list()).length, 1)
+  } finally {
+    await f.close()
+  }
+})
+
+test('slow voice normalization preserves instruction order and leaves controls responsive', async () => {
+  const f = await fixture()
+  const originalFetch = globalThis.fetch
+  let release!: () => void
+  const gate = new Promise<void>((resolve) => {
+    release = resolve
+  })
+  let entered!: () => void
+  const downloading = new Promise<void>((resolve) => {
+    entered = resolve
+  })
+  globalThis.fetch = async (input) => {
+    if (String(input).includes('api.telegram.org/file/')) {
+      entered()
+      await gate
+      return new Response('fixture audio')
+    }
+    return Response.json({ candidates: [{ content: { parts: [{ text: 'Fixture voice transcript' }] } }] })
+  }
+  try {
+    await f.relay.bot.handleUpdate(message(1, 'Use the following voice note'))
+    const voice = message(2)
+    delete voice.message!.text
+    voice.message!.voice = { file_id: 'fixture', file_unique_id: 'fixture', duration: 2 }
+    voice.message!.reply_to_message = {
+      ...message(91, 'Quoted context').message!,
+      reply_to_message: undefined,
+    }
+    await f.relay.bot.handleUpdate(voice)
+    const processing = f.relay.drainInbox(true)
+    await downloading
+    await f.relay.bot.handleUpdate(message(3, '/status'))
+    assert.ok(f.replies.some((text) => text.includes('2 incoming messages')))
+    assert.ok(f.replies.some((text) => text.includes(`Ez relay: ${packageVersion} (running)`)))
+    await f.relay.bot.handleUpdate(message(4, 'Next instruction'))
+    assert.equal(f.launched.length, 0)
+    release()
+    await processing
+    assert.equal(f.launched[0][0], 'Use the following voice note')
+    assert.match(f.launched[0][1], /Quoted context/)
+    assert.match(f.launched[0][1], /Fixture voice transcript/)
+    assert.equal(f.launched[0].length, 2)
+    assert.equal((await new InboxStore(f.dir).status()).pending, 1)
+  } finally {
+    release()
+    globalThis.fetch = originalFetch
+    await f.close()
+  }
+})
+
+test('cancel clears accepted and queued work, never spawns a cancelled run, and status exposes delivery uncertainty', async () => {
+  const f = await fixture()
+  try {
+    const runs = new RunStore(f.dir)
+    const run = await runs.create({ chatId: 101, telegramUserId: 101, texts: ['queued'] })
+    const out = await runs.enqueueMessage(run.id, 'fixture delivery')
+    await runs.claimOutbox(out.id)
+    await f.relay.bot.handleUpdate(message(1))
+    await f.relay.bot.handleUpdate(message(2, '/cancel'))
+    await f.relay.drainInbox(true)
+    assert.equal(f.launched.length, 0)
+    assert.equal((await runs.get(run.id))?.status, 'cancelled')
+    await f.relay.bot.handleUpdate(message(3, '/status'))
+    assert.match(f.replies.at(-1)!, /0 runs; 0 incoming messages/)
+    assert.match(f.replies.at(-1)!, /1 unknown/)
+  } finally {
+    await f.close()
+  }
+})
+
+test('replayed approval decision can recover its wake but a new callback cannot replay consent', async () => {
+  const f = await fixture()
+  try {
+    const runs = new RunStore(f.dir)
+    const run = await runs.create({ chatId: 101, telegramUserId: 101, texts: ['approval'] })
+    await runs.patch(run.id, { status: 'completed' })
+    const approvals = new ApprovalStore(f.dir)
+    await approvals.requestApproval('fixture_action', 'Fixture?', run.id)
+    const update: Update = {
+      update_id: 11,
+      callback_query: {
+        id: 'fixture',
+        chat_instance: 'fixture',
+        from: message(1).message!.from!,
+        message: message(1).message!,
+        data: 'approval:fixture_action:approve',
+      },
+    }
+    await f.relay.bot.handleUpdate(update)
+    // Simulate crash after consent persisted, before its agent wake was created.
+    await approvals.recordDecision('fixture_action', 'approved', 101, 11)
+    await f.restart()
+    await f.relay.drainInbox(true)
+    assert.equal(f.launched.length, 1)
+    assert.match(f.launched[0][0], /approval_decision/)
+    await assert.rejects(approvals.recordDecision('fixture_action', 'approved', 101, 12), /already decided/)
+  } finally {
+    await f.close()
+  }
+})
+
+test('revoked owner intake never executes or recreates a pairing request on replay', async () => {
+  const f = await fixture()
+  try {
+    await f.relay.bot.handleUpdate(message(1))
+    const control = new ControlStore(f.dir, 1000)
+    await control.revokeOwner()
+    await f.relay.drainInbox(true)
+    assert.equal(f.launched.length, 0)
+    assert.equal((await control.status()).owner, null)
+    assert.deepEqual((await control.status()).pending, [])
+    assert.deepEqual(f.replies, [])
+  } finally {
+    await f.close()
+  }
+})
+
+test('cancelling during a download prevents dispatch even when normalization finishes', async () => {
+  const f = await fixture()
+  const originalFetch = globalThis.fetch
+  let release!: () => void
+  const gate = new Promise<void>((resolve) => {
+    release = resolve
+  })
+  let entered!: () => void
+  const downloading = new Promise<void>((resolve) => {
+    entered = resolve
+  })
+  globalThis.fetch = async () => {
+    entered()
+    await gate
+    return new Response('Fixture document')
+  }
+  try {
+    const doc = message(1)
+    delete doc.message!.text
+    doc.message!.document = { file_id: 'fixture', file_unique_id: 'fixture', file_name: 'fixture.txt' }
+    await f.relay.bot.handleUpdate(doc)
+    const processing = f.relay.drainInbox(true)
+    await downloading
+    await f.relay.bot.handleUpdate(message(2, '/cancel'))
+    release()
+    await processing
+    assert.equal(f.launched.length, 0)
+    assert.equal((await new RunStore(f.dir).list()).length, 0)
+    assert.equal((await new InboxStore(f.dir).status()).pending, 0)
+  } finally {
+    release()
+    globalThis.fetch = originalFetch
+    await f.close()
+  }
+})
+
+test('media failure quarantines its instruction batch instead of executing incomplete context', async () => {
+  const f = await fixture()
+  const originalFetch = globalThis.fetch
+  globalThis.fetch = async () => new Response('unavailable', { status: 503 })
+  try {
+    await f.relay.bot.handleUpdate(message(1, 'Use the following attachment'))
+    const doc = message(2)
+    delete doc.message!.text
+    doc.message!.document = { file_id: 'fixture', file_unique_id: 'fixture', file_name: 'fixture.txt' }
+    await f.relay.bot.handleUpdate(doc)
+    await f.relay.drainInbox(true)
+    assert.equal(f.launched.length, 0)
+    assert.deepEqual(await new InboxStore(f.dir).status(), { pending: 0, failed: 1 })
+    globalThis.fetch = async () => new Response('Recovered fixture document')
+    await f.relay.bot.handleUpdate(message(3, '/retry'))
+    await f.relay.drainInbox(true)
+    assert.equal(f.launched.length, 1)
+    assert.equal(f.launched[0][0], 'Use the following attachment')
+    assert.match(f.launched[0][1], /Attached document/)
+    await f.relay.bot.handleUpdate(message(4, '/retry'))
+    await f.relay.drainInbox(true)
+    assert.equal(f.launched.length, 1)
+  } finally {
+    globalThis.fetch = originalFetch
+    await f.close()
+  }
+})

package/test/owner-help.test.mjs

@@ -0,0 +1,10 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {execFileSync} from 'node:child_process';
+
+test('owner help succeeds without loading control configuration or credentials',()=>{
+  const output=execFileSync(process.execPath,['bin/ezenciel-agents-owner.mjs','--help'],{
+    encoding:'utf8',env:{PATH:process.env.PATH,EZ_CONTROL_DIR:'/dev/null/not-a-directory'}
+  });
+  assert.match(output,/Usage: ezenciel-agents-owner status/);
+});

package/test/plugin-manager.test.mjs

@@ -0,0 +1,157 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import {snapshot,init as initManager,validate,compose,locked} from '../src/plugins/manager.mjs';
+// Synthetic manager tests explicitly opt out of the product's default packages.
+async function init(home,workspace,catalog,hostConfig) {
+ const file=path.join(path.dirname(home),'test-catalog.json');
+ if(!catalog)await fs.writeFile(file,'{}');
+ return initManager(home,workspace,catalog||file,hostConfig);
+}
+const exec=promisify(execFile),bin=new URL('../bin/ezenciel-agents-tools.mjs',import.meta.url).pathname;
+async function fixture(t) {
+ const root=await fs.mkdtemp(path.join(tmpdir(),'ez-tools-'));t.after(()=>fs.rm(root,{recursive:true,force:true}));
+ const source=path.join(root,'source'),home=path.join(root,'tools'),workspace=path.join(root,'mind'),fake=path.join(root,'fake');
+ for(const d of [source,workspace,fake])await fs.mkdir(d);
+ const manifest={schemaVersion:1,id:'sample',version:'0.1.0',description:'Synthetic',commands:{sample:{executable:'client.mjs',args:[]}},skills:['SKILL.md']};
+ const deployment={schemaVersion:1,services:{sample:{buildTarget:'runtime',volumes:{data:'/data'},workspace:true,healthcheck:['node','--version']}},commands:{sample:{service:'sample',argv:['node','/app/client.mjs'],suffix:[]}}};
+ for(const [name,value]of Object.entries({'package.json':JSON.stringify({files:['client.mjs','SKILL.md']}),'ez-plugin.json':JSON.stringify(manifest),'ez-deployment.json':JSON.stringify(deployment),'Dockerfile':'FROM scratch AS runtime','.dockerignore':'','client.mjs':'','SKILL.md':'Synthetic'}))await fs.writeFile(path.join(source,name),value);
+ const log=path.join(root,'docker.log');
+ await fs.writeFile(path.join(fake,'docker'),`#!${process.execPath}\nrequire('fs').appendFileSync(${JSON.stringify(log)},JSON.stringify({argv:process.argv.slice(2),secret:process.env.TELEGRAM_BOT_TOKEN})+'\\n');\nif(process.argv.includes('run')){console.log(JSON.stringify(process.argv.slice(process.argv.indexOf('/app/client.mjs')+1)));process.exit(process.argv.includes('fail')?17:0)}\n`,{mode:0o700});
+ const env={...process.env,PATH:fake+path.delimiter+process.env.PATH,TELEGRAM_BOT_TOKEN:'must-not-leak'};
+ const call=(...args)=>exec(process.execPath,[bin,'--home',home,...args],{env});
+ return {root,source,home,workspace,fake,log,manifest,deployment,env,call};
+}
+test('catalog paths resolve relative to the catalog and pin each new agent independently',async t=>{
+ const f=await fixture(t),catalog=path.join(f.root,'defaults.json');
+ await fs.writeFile(catalog,JSON.stringify({sample:'./source'}));
+ await initManager(f.home,f.workspace,catalog);
+ const first=JSON.parse((await f.call('plugins','available')).stdout);
+ assert.equal(first.sample.source,await fs.realpath(f.source));
+ await fs.writeFile(path.join(f.source,'SKILL.md'),'new release');
+ const second=path.join(f.root,'second');await initManager(second,f.workspace,catalog);
+ const next=JSON.parse(await fs.readFile(path.join(second,'config.json'),'utf8'));
+ assert.notEqual(first.sample.revision,next.catalog.sample.revision);
+ assert.deepEqual(JSON.parse((await f.call('plugins','available')).stdout),first);
+});
+test('initialization seeds tool guidance and preserves existing mind notes',async t=>{
+ const f=await fixture(t);await init(f.home,f.workspace);
+ const template=await fs.readFile(new URL('../templates/agent/TOOLS.md',import.meta.url),'utf8');
+ const target=path.join(f.workspace,'TOOLS.md');
+ assert.ok((await fs.readFile(target,'utf8')).startsWith(template));
+ const existing='Owner-maintained tool notes\n';await fs.writeFile(target,existing);
+ await init(path.join(f.root,'other-tools'),f.workspace);
+ assert.ok((await fs.readFile(target,'utf8')).startsWith(existing));
+});
+test('bound launcher installs without startup; literal args and exit codes; scopes and secrets',async t=>{
+ const f=await fixture(t);const p=await snapshot(f.source);await init(f.home,f.workspace);
+ const install=['plugins','install','sample','--source',f.source,'--revision',p.revision];
+ await f.call(...install);assert.equal(JSON.parse((await f.call(...install)).stdout).existing,true);
+ let lines=(await fs.readFile(f.log,'utf8')).trim().split('\n').map(JSON.parse);assert.equal(lines.length,1);assert(lines[0].argv.includes('build'));assert(!lines[0].argv.includes('up'));assert.equal(lines[0].secret,undefined);
+ const literal=['--home','/other','$(touch /tmp/nope)','a b','x;y','--text-file','has spaces.txt'];
+ assert.deepEqual(JSON.parse((await exec(path.join(f.home,'bin','ez'),['sample',...literal],{env:f.env})).stdout),literal);
+ await assert.rejects(f.call('sample','fail'),e=>e.code===17);
+ await assert.rejects(f.call('plugins','start','../sample'));
+ await assert.rejects(f.call('tools','install','sample'));
+ await f.call('plugins','start','sample');await f.call('plugins','stop','sample');
+ await f.call('plugins','uninstall','sample');await assert.rejects(f.call('sample','doctor'));
+ await f.call(...install); // preserved snapshot is safe to reuse
+ lines=(await fs.readFile(f.log,'utf8')).trim().split('\n').map(JSON.parse);assert(lines.every(x=>x.secret===undefined));assert(lines.every(x=>!x.argv.includes('-v')));
+ const mode=(await fs.stat(path.join(f.home,'registry.json'))).mode&0o777;assert.equal(mode,0o600);
+});
+test('changed source, symlinks, reserved aliases, arbitrary Docker fields rejected',async t=>{
+ const f=await fixture(t),p=await snapshot(f.source);await init(f.home,f.workspace);
+ await fs.writeFile(path.join(f.source,'client.mjs'),'changed');await assert.rejects(f.call('plugins','install','sample','--source',f.source,'--revision',p.revision));
+ await fs.rm(path.join(f.source,'client.mjs'));await fs.symlink('/etc/passwd',path.join(f.source,'client.mjs'));await assert.rejects(snapshot(f.source),/symlink/);
+ const d=structuredClone(f.deployment);d.services.sample.privileged=true;assert.throws(()=>validate(f.manifest,d,p.files),/unknown/);
+ const m=structuredClone(f.manifest);m.commands={plugins:m.commands.sample};const bad=structuredClone(f.deployment);bad.commands={plugins:bad.commands.sample};assert.throws(()=>validate(m,bad,p.files),/Reserved/);
+});
+test('registry corruption, active writer lock and alias collision fail closed',async t=>{
+ const f=await fixture(t),p=await snapshot(f.source);await init(f.home,f.workspace);
+ await locked(f.home,()=>assert.rejects(locked(f.home,()=>{}),/busy/));
+ await f.call('plugins','install','sample','--source',f.source,'--revision',p.revision);
+ const m={...f.manifest,id:'second'};await fs.writeFile(path.join(f.source,'ez-plugin.json'),JSON.stringify(m));const other=await snapshot(f.source);
+ await assert.rejects(f.call('plugins','install','second','--source',f.source,'--revision',other.revision),/collision/);
+ await fs.writeFile(path.join(f.home,'registry.json'),'{bad');await assert.rejects(f.call('sample','doctor'));
+});
+test('Compose resources are namespaced, private, and restricted to owning workspace',async t=>{
+ const f=await fixture(t),p=await snapshot(f.source);
+ const c=compose({workspace:f.workspace},{source:f.source,project:'ezp-synthetic',revision:p.revision,deployment:p.deployment});
+ assert.equal(c.name,'ezp-synthetic');assert.equal(c.services.sample.ports,undefined);assert.equal(c.services.sample.privileged,undefined);assert.equal(c.services.sample.volumes[1].read_only,true);assert.deepEqual(c.services.sample.cap_drop,['ALL']);
+});
+test('host onboarding binds local ez without replacing global commands',async t=>{
+ const f=await fixture(t),native=path.join(f.root,'native'),config=path.join(f.root,'host.json');await fs.mkdir(native);await fs.writeFile(path.join(native,'native-tool'),'hello');
+ await fs.writeFile(config,JSON.stringify({cli:'synthetic',agents:[{name:'demo',workspace:f.workspace,binDir:native}]}));
+ await init(f.home,f.workspace,undefined,config);const host=JSON.parse(await fs.readFile(config));assert.equal(host.agents[0].binDir,path.join(await fs.realpath(f.home),'bin'));assert.equal(host.agents[0].toolsHome,await fs.realpath(f.home));assert.equal(await fs.readFile(path.join(host.agents[0].binDir,'native-tool'),'utf8'),'hello');
+  await assert.rejects(init(f.home,f.workspace),/exists/);
+});
+test('host install exposes runnable public commands without source aliases',async t=>{
+ const f=await fixture(t),native=path.join(f.root,'native'),config=path.join(f.root,'host.json');
+ await fs.mkdir(native);
+ await fs.symlink('ezenciel-agents-message',path.join(native,'ezenciel-agents-message'));
+ await fs.writeFile(config,JSON.stringify({cli:'codex',agents:[{name:'demo',workspace:f.workspace,binDir:native}]}));
+ await init(f.home,f.workspace,undefined,config);
+ const manifest=JSON.parse(await fs.readFile(new URL('../package.json',import.meta.url)));
+ for(const [name,entry] of Object.entries(manifest.bin)) assert.equal(await fs.realpath(path.join(f.home,'bin',name)),await fs.realpath(new URL('../'+entry,import.meta.url)));
+ const result=await exec(path.join(f.home,'bin','ezenciel-agents-message'),['--help'],{env:{...process.env,PATH:path.dirname(process.execPath)+path.delimiter+process.env.PATH}});
+ assert.match(result.stdout,/Usage: ezenciel-agents-message/);
+});
+test('copying another agent registry is rejected before any Docker operation',async t=>{
+ const f=await fixture(t),other=path.join(f.root,'other');await init(f.home,f.workspace);await init(other,f.workspace);
+ await fs.copyFile(path.join(f.home,'registry.json'),path.join(other,'registry.json'));
+ await assert.rejects(exec(process.execPath,[bin,'--home',other,'tools','list'],{env:f.env}),/Corrupt registry/);
+ await assert.rejects(fs.stat(f.log),e=>e.code==='ENOENT');
+});
+
+test('v2 supports bounded dependency graphs and generated private secrets',async t=>{
+ const f=await fixture(t),p=await snapshot(f.source);
+ const d=structuredClone(f.deployment);d.schemaVersion=2;d.secrets=['db-password'];
+ d.services.database={image:'example/database@sha256:'+'a'.repeat(64),user:'999:999',healthcheck:['check'],memoryMiB:128,environment:{PASSWORD:{secret:'db-password'}}};
+ d.services.sample.dependsOn=['database'];d.services.sample.environment={URL:{secret:'db-password',prefix:'db://',suffix:'@database'}};
+ validate(f.manifest,d,p.files);
+ const c=compose({workspace:f.workspace},{source:f.source,project:'ezp-synthetic',revision:p.revision,deployment:d},{'db-password':'b'.repeat(64)});
+ assert.equal(c.services.database.user,'999:999');assert.equal(c.services.sample.depends_on.database.condition,'service_healthy');assert.equal(c.services.sample.environment.URL,'db://'+'b'.repeat(64)+'@database');
+ assert.equal(c.services.database.mem_limit,'128m');assert.throws(()=>compose({workspace:f.workspace}, {source:f.source,project:'ezp-synthetic',revision:p.revision,deployment:d}),/Missing/);
+ for(const change of [x=>x.services.database.user='0:0',x=>x.services.database.environment.PASSWORD={secret:'undeclared'},x=>x.services.database.environment.PASSWORD='${HOST_SECRET}',x=>x.services.database.dependsOn=['sample'],x=>x.services.sample.dependsOn=['missing'],x=>x.services.sample.ports=['9999:9999']]){const bad=structuredClone(d);change(bad);assert.throws(()=>validate(f.manifest,bad,p.files));}
+ const old=structuredClone(d);old.schemaVersion=1;assert.throws(()=>validate(f.manifest,old,p.files));
+});
+test('catalog publication pins reviewed source without install or Docker calls',async t=>{
+ const f=await fixture(t),p=await snapshot(f.source);await init(f.home,f.workspace);
+ await f.call('plugins','catalog-add','sample','--source',f.source,'--revision',p.revision);
+ const available=JSON.parse((await f.call('plugins','available')).stdout);assert.equal(available.sample.revision,p.revision);
+ assert.deepEqual(JSON.parse((await f.call('tools','list')).stdout),{});await assert.rejects(fs.stat(f.log),e=>e.code==='ENOENT');
+ await assert.rejects(f.call('plugins','catalog-add','wrong','--source',f.source,'--revision',p.revision),/pin/);
+});
+
+test('plugin help documents data-preserving uninstall without a plugin identifier',async t=>{
+ const f=await fixture(t);await init(f.home,f.workspace);
+ const help=JSON.parse((await f.call('plugins','--help')).stdout);
+ assert.ok(help.commands.includes('uninstall <id>'));assert.match(help.uninstall,/retains all volumes and secrets/);
+ for(const action of ['install','uninstall','start'])assert.deepEqual(JSON.parse((await f.call('plugins',action,'--help')).stdout),help);
+});
+
+test('inspection reveals stale catalog pin without changing it; explicit repin permits install',async t=>{
+ const f=await fixture(t);await init(f.home,f.workspace);
+ const old=await snapshot(f.source);
+ await f.call('plugins','catalog-add','sample','--source',f.source,'--revision',old.revision);
+ await fs.writeFile(path.join(f.source,'SKILL.md'),'Reviewed updated instructions');
+ const inspected=JSON.parse((await f.call('plugins','inspect','sample')).stdout);
+ assert.equal(inspected.catalogMatches,false);assert.equal(inspected.catalogRevision,old.revision);
+ assert.equal(inspected.source,await fs.realpath(f.source));assert.notEqual(inspected.revision,old.revision);
+ await assert.rejects(f.call('plugins','install','sample'),/Inspection is read-only/);
+ assert.equal(JSON.parse((await f.call('plugins','available')).stdout).sample.revision,old.revision);
+ await f.call('plugins','catalog-add','sample','--source',inspected.source,'--revision',inspected.revision);
+ assert.equal(JSON.parse((await f.call('plugins','inspect','sample')).stdout).catalogMatches,true);
+ assert.equal(JSON.parse((await f.call('plugins','install','sample')).stdout).revision,inspected.revision);
+});
+
+
+test('plugin versions accept SemVer beta releases and reject malformed versions',async t=>{
+ const f=await fixture(t),p=await snapshot(f.source);
+ for(const version of ['0.1.0','0.1.0-beta.1','1.2.3-rc.0+build.12'])validate({...f.manifest,version},f.deployment,p.files);
+ for(const version of ['01.2.3','1.2','1.2.3-beta.01','1.2.3-','1.2.3+','1.2.3/beta',null,{}])assert.throws(()=>validate({...f.manifest,version},f.deployment,p.files),/manifest version/);
+});

package/test/publish-guard.test.ts

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const script = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../scripts/assert-local-registry.mjs')
+
+const runGuard = (env: NodeJS.ProcessEnv) =>
+  spawnSync(process.execPath, [script], { encoding: 'utf8', env: { ...process.env, ...env } })
+
+test('blocks a public npm registry', () => {
+  const result = runGuard({ npm_config_registry: 'https://registry.npmjs.org/' })
+  assert.notEqual(result.status, 0)
+  assert.match(result.stderr, /Refusing to publish outside the local ez registry/)
+})
+
+test('allows the local verdaccio registry', () => {
+  const result = runGuard({ npm_config_registry: 'http://127.0.0.1:4873/' })
+  assert.equal(result.status, 0, result.stderr)
+})

package/test/reaction.test.ts

@@ -0,0 +1,122 @@
+import assert from 'node:assert/strict'
+import { execFile } from 'node:child_process'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import { promisify } from 'node:util'
+import { isSupportedReactionEmoji, normalizeReactionEmoji, TELEGRAM_REACTIONS } from '../src/reaction.js'
+import { RunStore } from '../src/runs.js'
+
+const execFileAsync = promisify(execFile)
+const reactScriptPath = path.resolve('src/react.ts')
+
+const fixture = async (run: (store: RunStore, dir: string) => Promise<void>): Promise<void> => {
+  const directory = await mkdtemp(path.join(tmpdir(), 'ez-reactions-'))
+  try {
+    await run(new RunStore(directory), directory)
+  } finally {
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
+test('normalizes standard Telegram reaction emojis', () => {
+  assert.equal(normalizeReactionEmoji('👍'), '👍')
+  assert.equal(normalizeReactionEmoji('🔥'), '🔥')
+  assert.equal(normalizeReactionEmoji('👀'), '👀')
+  assert.equal(normalizeReactionEmoji('🫡'), '🫡')
+  assert.equal(normalizeReactionEmoji('❤'), '❤')
+  assert.equal(isSupportedReactionEmoji('👍'), true)
+  assert.equal(isSupportedReactionEmoji('👀'), true)
+})
+
+test('normalizes emojis with variation selector FE0F', () => {
+  // Red heart with FE0F should normalize to standard ❤
+  assert.equal(normalizeReactionEmoji('❤️'), '❤')
+  // Lightning bolt with FE0F should normalize to ⚡
+  assert.equal(normalizeReactionEmoji('⚡️'), '⚡')
+  // Dove with FE0F should normalize to 🕊
+  assert.equal(normalizeReactionEmoji('🕊️'), '🕊')
+  // Shrugging man/woman with FE0F
+  assert.equal(normalizeReactionEmoji('🤷‍♂️'), '🤷‍♂')
+  assert.equal(normalizeReactionEmoji('🤷‍♀️'), '🤷‍♀')
+  // Heart on fire
+  assert.equal(normalizeReactionEmoji('❤\uFE0F\u200D\u{1F525}'), '❤‍🔥')
+})
+
+test('rejects invalid or unsupported reaction emojis', () => {
+  assert.equal(normalizeReactionEmoji('✅'), undefined)
+  assert.equal(normalizeReactionEmoji('⏳'), undefined)
+  assert.equal(normalizeReactionEmoji('❌'), undefined)
+  assert.equal(normalizeReactionEmoji('🚀'), undefined)
+  assert.equal(normalizeReactionEmoji(''), undefined)
+  assert.equal(normalizeReactionEmoji('  '), undefined)
+  assert.equal(normalizeReactionEmoji(undefined), undefined)
+  assert.equal(normalizeReactionEmoji(null), undefined)
+  assert.equal(isSupportedReactionEmoji('✅'), false)
+  assert.equal(isSupportedReactionEmoji('⏳'), false)
+})
+
+test('RunStore enqueues valid reaction and normalizes emoji', async () => fixture(async (store) => {
+  const run = await store.create({ chatId: 123, telegramUserId: 123, texts: ['hi'], messageId: 456 })
+  await store.patch(run.id, { status: 'running' })
+
+  const item = await store.enqueueReaction(run.id, '❤️')
+  assert.equal(item.type, 'reaction')
+  assert.equal(item.emoji, '❤') // Normalized without FE0F
+  assert.equal(item.messageId, 456)
+  assert.equal(item.chatId, 123)
+
+  const pending = await store.pendingOutbox()
+  assert.equal(pending.length, 1)
+  assert.equal(pending[0].emoji, '❤')
+}))
+
+test('RunStore rejects invalid reaction emoji with error', async () => fixture(async (store) => {
+  const run = await store.create({ chatId: 123, telegramUserId: 123, texts: ['hi'], messageId: 456 })
+  await store.patch(run.id, { status: 'running' })
+
+  await assert.rejects(
+    store.enqueueReaction(run.id, '✅'),
+    /Invalid Telegram reaction emoji "✅"/,
+  )
+  await assert.rejects(
+    store.enqueueReaction(run.id, '⏳'),
+    /Invalid Telegram reaction emoji "⏳"/,
+  )
+}))
+
+test('ezenciel-agents-react CLI enforces EZ_RUN_ID and valid emoji', async () => fixture(async (store, dir) => {
+  // Missing EZ_RUN_ID
+  await assert.rejects(
+    execFileAsync('pnpm', ['exec', 'tsx', reactScriptPath, '--emoji', '👍'], {
+      env: { ...process.env, EZ_RUN_ID: '', EZ_CONTROL_DIR: dir },
+    }),
+    (err: any) => {
+      assert.match(err.stderr, /EZ_RUN_ID is required/)
+      return true
+    },
+  )
+
+  // Invalid emoji
+  const run = await store.create({ chatId: 123, telegramUserId: 123, texts: ['hi'], messageId: 456 })
+  await store.patch(run.id, { status: 'running' })
+
+  await assert.rejects(
+    execFileAsync('pnpm', ['exec', 'tsx', reactScriptPath, '--emoji', '✅'], {
+      env: { ...process.env, EZ_RUN_ID: run.id, EZ_CONTROL_DIR: dir },
+    }),
+    (err: any) => {
+      assert.match(err.stderr, /Invalid Telegram reaction emoji "✅"/)
+      return true
+    },
+  )
+
+  // Valid emoji succeeds
+  const { stdout } = await execFileAsync('pnpm', ['exec', 'tsx', reactScriptPath, '--emoji', '👍'], {
+    env: { ...process.env, EZ_RUN_ID: run.id, EZ_CONTROL_DIR: dir },
+  })
+  const parsed = JSON.parse(stdout)
+  assert.equal(parsed.ok, true)
+  assert.equal(parsed.emoji, '👍')
+}))