@jc_stack/ez-agents 0.1.0-beta.12

package/test/read-request.test.ts

@@ -0,0 +1,134 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readRequest } from '../src/read-request.js'
+
+test('repeatable input retries connection reset and 503 with bounded backoff', async (t) => {
+  let attempts = 0
+  const delays: number[] = []
+  t.mock.method(globalThis, 'fetch', async () => {
+    attempts++
+    if (attempts === 1) throw new TypeError('fetch failed', { cause: { code: 'ECONNRESET' } })
+    return attempts === 2 ? new Response('', { status: 503 }) : new Response('transcript')
+  })
+  assert.equal(
+    await readRequest(
+      'Fixture transcription',
+      'https://example.invalid',
+      {},
+      (r) => r.text(),
+      async (ms) => {
+        delays.push(ms)
+      },
+    ),
+    'transcript',
+  )
+  assert.equal(attempts, 3)
+  assert.deepEqual(delays, [1000, 2000])
+})
+
+test('exhausted input retries report stage and nested network cause without credentials', async (t) => {
+  let attempts = 0
+  t.mock.method(globalThis, 'fetch', async () => {
+    attempts++
+    throw new TypeError('fetch failed secret-token-url', {
+      cause: new AggregateError([{ code: 'ETIMEDOUT' }]),
+    })
+  })
+  await assert.rejects(
+    readRequest(
+      'Telegram attachment download',
+      'https://example.invalid/secret-token',
+      {},
+      (r) => r.text(),
+      async () => {},
+    ),
+    (error) => {
+      assert.match((error as Error).message, /Telegram attachment download: ETIMEDOUT \(after 3 attempts\)/)
+      assert.equal((error as Error).message.includes('secret-token'), false)
+      return true
+    },
+  )
+  assert.equal(attempts, 3)
+})
+
+test('authentication failures and certificate errors are not retried', async (t) => {
+  let attempts = 0
+  const fetch = t.mock.method(globalThis, 'fetch', async () => {
+    attempts++
+    return new Response('secret provider payload', { status: 401 })
+  })
+  await assert.rejects(
+    readRequest(
+      'STT',
+      'https://example.invalid',
+      {},
+      (r) => r.text(),
+      async () => assert.fail('must not retry'),
+    ),
+    /STT: HTTP 401 \(after 1 attempt\)/,
+  )
+  assert.equal(attempts, 1)
+  fetch.mock.mockImplementation(async () => {
+    throw new TypeError('fetch failed', { cause: { code: 'CERT_HAS_EXPIRED' } })
+  })
+  await assert.rejects(
+    readRequest(
+      'STT',
+      'https://example.invalid',
+      {},
+      (r) => r.text(),
+      async () => assert.fail('must not retry'),
+    ),
+    /CERT_HAS_EXPIRED.*1 attempt/,
+  )
+})
+
+test('429 honors Retry-After and does not shorten a long provider cooldown', async (t) => {
+  let attempts = 0
+  const delays: number[] = []
+  const fetch = t.mock.method(globalThis, 'fetch', async () =>
+    ++attempts === 1
+      ? new Response('', { status: 429, headers: { 'retry-after': '5' } })
+      : new Response('ok'),
+  )
+  await readRequest(
+    'STT',
+    'https://example.invalid',
+    {},
+    (r) => r.text(),
+    async (ms) => {
+      delays.push(ms)
+    },
+  )
+  assert.deepEqual(delays, [5000])
+  fetch.mock.mockImplementation(
+    async () => new Response('', { status: 429, headers: { 'retry-after': '120' } }),
+  )
+  await assert.rejects(
+    readRequest(
+      'STT',
+      'https://example.invalid',
+      {},
+      (r) => r.text(),
+      async () => assert.fail('must not retry before provider cooldown'),
+    ),
+    /HTTP 429.*1 attempt/,
+  )
+})
+
+test('a socket failure while consuming the body is retried, not just fetch headers', async (t) => {
+  let attempts = 0
+  t.mock.method(globalThis, 'fetch', async () => new Response('ok'))
+  const result = await readRequest(
+    'Download',
+    'https://example.invalid',
+    {},
+    async (r) => {
+      if (++attempts === 1) throw new TypeError('terminated', { cause: { code: 'UND_ERR_SOCKET' } })
+      return r.text()
+    },
+    async () => {},
+  )
+  assert.equal(result, 'ok')
+  assert.equal(attempts, 2)
+})

package/test/relay.test.ts

@@ -0,0 +1,254 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, readdir, readFile } 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 { ApprovalStore } from '../src/approval.js'
+import { initialPreset } from '../src/ai.js'
+
+const message = (userId = 101, group = false): Update => ({
+  update_id: 1,
+  message: {
+    message_id: 1,
+    date: 0,
+    text: 'hello',
+    from: { id: userId, is_bot: false, first_name: 'Fixture' },
+    chat: group
+      ? { id: -101, type: 'group', title: 'Fixture' }
+      : { id: userId, type: 'private', first_name: 'Fixture' },
+  },
+})
+
+const until = async (check: () => Promise<boolean>) => {
+  const deadline = Date.now() + 5000
+  while (!(await check())) {
+    if (Date.now() > deadline) throw new Error('Timed out waiting for relay')
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+}
+
+test('owner stop terminates the writer and starts queued work without overlap', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-stop-'))
+  const children: ReturnType<typeof spawn>[] = []
+  const relay = createRelay(
+    {
+      controlDir: dir,
+      workspace: dir,
+      pairingTtlMs: 1000,
+      executorTimeoutMs: 1000,
+      executorCli: 'grok',
+      telegramBotToken: 'fixture',
+    },
+    async () => {
+      assert.ok(children.every((child) => child.exitCode !== null || child.signalCode !== null))
+      const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], {
+        detached: process.platform !== 'win32',
+      })
+      await once(child, 'spawn')
+      children.push(child)
+      return { child, cleanup: async () => {}, stdout: '' }
+    },
+  )
+  relay.bot.botInfo = {
+    id: 999,
+    is_bot: true,
+    first_name: 'Fixture',
+    username: 'fixture_bot',
+    can_join_groups: true,
+    can_read_all_group_messages: false,
+    supports_inline_queries: false,
+    can_connect_to_business: false,
+    has_main_web_app: false,
+    has_topics_enabled: false,
+    allows_users_to_create_topics: false,
+    can_manage_bots: false,
+    supports_join_request_queries: false,
+  }
+  relay.bot.api.config.use(async () => ({ ok: true, result: { message_id: 42 } }) as never)
+  try {
+    const control = new ControlStore(dir, 1000)
+    await control.requestPairing(101, 101)
+    await control.approveOwner(101)
+    await relay.bot.handleUpdate(message())
+    await until(async () => children.length === 1)
+    const runs = new RunStore(dir)
+    await runs.create({ chatId: 101, telegramUserId: 101, texts: ['queued follow-up'],
+      execution: await control.captureChoice(initialPreset('grok')) })
+    const stop = message()
+    stop.message!.text = '/stop'
+    await relay.bot.handleUpdate(stop)
+    await until(async () => children.length === 2)
+    assert.equal((await runs.list()).filter((run) => run.status === 'failed').length, 1)
+    await relay.stop()
+    await until(async () => children[1].signalCode !== null)
+    await until(async () => (await runs.list()).every((run) => run.status !== 'running'))
+  } finally {
+    await relay.stop()
+    for (const child of children) {
+      if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL')
+    }
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('real Telegram handlers never launch for first DM, another sender, group, or forged callback', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-handler-'))
+  let launched = 0
+  const relay = createRelay(
+    {
+      controlDir: dir,
+      workspace: dir,
+      pairingTtlMs: 1000,
+      executorTimeoutMs: 1000,
+      executorCli: 'grok',
+      telegramBotToken: 'fixture',
+    },
+    async () => {
+      launched++
+      throw new Error('Executor must not start')
+    },
+  )
+  const calls: string[] = []
+  relay.bot.botInfo = {
+    id: 999,
+    is_bot: true,
+    first_name: 'Fixture',
+    username: 'fixture_bot',
+    can_join_groups: true,
+    can_read_all_group_messages: false,
+    supports_inline_queries: false,
+    can_connect_to_business: false,
+    has_main_web_app: false,
+    has_topics_enabled: false,
+    allows_users_to_create_topics: false,
+    can_manage_bots: false,
+    supports_join_request_queries: false,
+  }
+  relay.bot.api.config.use(async (_previous, method) => {
+    calls.push(method)
+    return { ok: true, result: true } as never
+  })
+  try {
+    await relay.bot.handleUpdate(message())
+    const control = new ControlStore(dir, 1000)
+    assert.equal((await control.status()).owner, null)
+    assert.equal(launched, 0)
+    await control.approveOwner(101)
+    calls.length = 0
+    await relay.bot.handleUpdate(message(202))
+    await relay.bot.handleUpdate(message(101, true))
+    assert.deepEqual(calls, [])
+    const original = message(101).message!
+    await relay.bot.handleUpdate({
+      update_id: 2,
+      callback_query: {
+        id: 'test',
+        chat_instance: 'fixture',
+        from: { id: 202, first_name: 'Intruder', is_bot: false },
+        message: original,
+        data: 'menu:new',
+      },
+    })
+    assert.equal(await control.getActiveSession(), null)
+    const runs = new RunStore(dir)
+    const run = await runs.create({ chatId: 101, telegramUserId: 101, texts: ['test approval'] })
+    const approvals = new ApprovalStore(dir)
+    await approvals.requestApproval('test_action', 'Harmless smoke test?', run.id)
+    await relay.bot.handleUpdate({
+      update_id: 3,
+      callback_query: {
+        id: 'forged',
+        chat_instance: 'fixture',
+        from: { id: 202, first_name: 'Intruder', is_bot: false },
+        message: original,
+        data: 'approval:test_action:approve',
+      },
+    })
+    assert.equal((await approvals.getDecision('test_action'))?.decision, 'pending')
+    await new Promise((resolve) => setTimeout(resolve, 2100))
+    assert.equal(launched, 0)
+  } finally {
+    await relay.stop()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('failed delivery is quarantined and never blindly retried', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-delivery-failure-'))
+  const relay = createRelay({
+    controlDir: dir,
+    workspace: dir,
+    pairingTtlMs: 1000,
+    executorTimeoutMs: 1000,
+    executorCli: 'grok',
+    telegramBotToken: 'fixture',
+  })
+  let sends = 0
+  relay.bot.api.config.use(async () => {
+    sends++
+    throw new Error('Ambiguous network failure')
+  })
+  try {
+    const control = new ControlStore(dir, 1000)
+    await control.requestPairing(101, 101)
+    await control.approveOwner(101)
+    const runs = new RunStore(dir)
+    const run = await runs.create({ chatId: 101, telegramUserId: 101, texts: ['hello'] })
+    const item = await runs.enqueueMessage(run.id, 'Hello')
+    await relay.drainOutbox()
+    await relay.drainOutbox()
+    assert.equal(sends, 1)
+    await assert.rejects(runs.waitForDelivery(item.id), /Ambiguous network failure/)
+    assert.deepEqual(await runs.deliveryStatus(), { failed: 0, unknown: 1 })
+    await assert.rejects(runs.waitForDelivery('missing', 1), /outcome unknown/)
+    assert.equal(
+      (await readdir(join(dir, 'outbox'))).filter((name) => name.endsWith('.failed.json')).length,
+      1,
+    )
+  } finally {
+    await relay.stop()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('outbox stores provider receipts and does not redeliver sent messages', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-delivery-'))
+  const relay = createRelay({
+    controlDir: dir,
+    workspace: dir,
+    pairingTtlMs: 1000,
+    executorTimeoutMs: 1000,
+    executorCli: 'grok',
+    telegramBotToken: 'fixture',
+  })
+  let sends = 0
+  relay.bot.api.config.use(async (_previous, method) => {
+    assert.equal(method, 'sendMessage')
+    sends++
+    return { ok: true, result: { message_id: 42 } } as never
+  })
+  try {
+    const control = new ControlStore(dir, 1000)
+    await control.requestPairing(101, 101)
+    await control.approveOwner(101)
+    const runs = new RunStore(dir)
+    const run = await runs.create({ chatId: 101, telegramUserId: 101, texts: ['hello'] })
+    const item = await runs.enqueueMessage(run.id, '**Hello** <world>')
+    await relay.drainOutbox()
+    await relay.drainOutbox()
+    assert.equal(sends, 1)
+    assert.deepEqual(((await runs.waitForDelivery(item.id)) as { messageIds: number[] }).messageIds, [42])
+    assert.deepEqual(await runs.pendingOutbox(), [])
+    const sent = (await readdir(join(dir, 'outbox'))).find((name) => name.endsWith('.sent.json'))!
+    assert.deepEqual(JSON.parse(await readFile(join(dir, 'outbox', sent), 'utf8')).receipt.messageIds, [42])
+  } finally {
+    await relay.stop()
+    await rm(dir, { recursive: true, force: true })
+  }
+})

package/test/release-entrypoints.test.mjs

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {mkdtemp,writeFile,mkdir,symlink,rm,readFile,realpath} 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 {fileURLToPath} from 'node:url';
+const exec=promisify(execFile),root=fileURLToPath(new URL('..',import.meta.url));
+test('public launchers resolve package root through npm-style symlinks',async t=>{
+ const temp=await mkdtemp(path.join(tmpdir(),'ez-public-bin-'));t.after(()=>rm(temp,{recursive:true,force:true}));
+ const bin=path.join(temp,'bin'),deployment=path.join(temp,'deployment');await mkdir(bin);await mkdir(deployment);
+ await writeFile(path.join(bin,'docker'),`#!/bin/sh\nexec '${process.execPath}' -e 'console.log(JSON.stringify(process.argv.slice(1)))' -- "$@"\n`,{mode:0o700});
+ const env={...process.env,PATH:bin+path.delimiter+process.env.PATH,EZ_DEPLOYMENT_DIR:deployment,EZ_AGENTS_HOME:path.join(temp,'agents')};
+ for(const name of ['docker','create','host'])await symlink(path.join(root,'bin','ezenciel-agents-'+name),path.join(bin,'ezenciel-agents-'+name));
+ const docker=JSON.parse((await exec(path.join(bin,'ezenciel-agents-docker'),['config'],{env})).stdout);
+ assert.equal(docker[docker.indexOf('--project-directory')+1],await realpath(root));
+ const create=JSON.parse((await exec(path.join(bin,'ezenciel-agents-create'),['--list'],{env})).stdout);
+ assert.equal(create[create.indexOf('--compose-file')+1],path.join(await realpath(root),'compose.yaml'));
+ await writeFile(path.join(deployment,'host-executor.json'),'{');
+ await assert.rejects(exec(path.join(bin,'ezenciel-agents-host'),[],{env}),e=>/JSON/.test(e.stderr)&&!e.stderr.includes('ERR_MODULE_NOT_FOUND'));
+});
+test('main version reports package metadata without starting a relay',async()=>{
+ const p=JSON.parse(await readFile(new URL('../package.json',import.meta.url)));
+ assert.equal((await exec(process.execPath,[path.join(root,'bin/ezenciel-agents.mjs'),'--version'])).stdout.trim(),p.version);
+});

package/test/runs.test.ts

@@ -0,0 +1,116 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import { parseMessageArgs, sendRunText } from '../src/message-send.js'
+import { RunStore } from '../src/runs.js'
+
+const fixture = async (run: (store: RunStore) => Promise<void>): Promise<void> => {
+  const directory = await mkdtemp(path.join(tmpdir(), 'ez-runs-'))
+  try {
+    await run(new RunStore(directory))
+  } finally {
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
+test('creates a queued run and binds chat id outside the workspace', async () => fixture(async (store) => {
+  const created = await store.create({ chatId: 101, telegramUserId: 101, texts: ['hello'] })
+  assert.match(created.id, /^r_/)
+  assert.equal(created.status, 'queued')
+  assert.equal((await store.get(created.id))?.chatId, 101)
+}))
+
+test('ez message writes an outbox item for the bound run, not a telegram send', async () => fixture(async (store) => {
+  const created = await store.create({ chatId: 9, telegramUserId: 9, texts: ['hello'] })
+  await store.patch(created.id, { status: 'running' })
+  const item = await sendRunText(store, created.id, '  started 1/100\n')
+  assert.equal(item.chatId, 9)
+  assert.equal(item.text, 'started 1/100')
+  const pending = await store.pendingOutbox()
+  assert.equal(pending.length, 1)
+  await store.markOutboxSent(item.id)
+  assert.equal((await store.pendingOutbox()).length, 0)
+}))
+
+test('ez message rejects an empty file and a finished run', async () => fixture(async (store) => {
+  const created = await store.create({ chatId: 1, telegramUserId: 1, texts: ['x'] })
+  await store.patch(created.id, { status: 'completed' })
+  await assert.rejects(sendRunText(store, created.id, 'hi'), /cannot send/)
+  await assert.rejects(sendRunText(store, created.id, '  \n'), /empty/)
+}))
+
+test('message CLI treats --text-file as the payload path', () => {
+  assert.deepEqual(parseMessageArgs(['--', '--text-file', './note.md']), { textFile: './note.md' })
+  assert.deepEqual(parseMessageArgs([]), { textFile: undefined })
+})
+
+test('message CLI parses --document, --voice, and --reply-to flags', () => {
+  const parsed = parseMessageArgs([
+    '--text-file', './note.md',
+    '--document', './invoice.pdf',
+    '--reply-to', '42',
+    '--voice', 'spoken note',
+  ])
+  assert.equal(parsed.textFile, './note.md')
+  assert.equal(parsed.document, './invoice.pdf')
+  assert.equal(parsed.replyTo, 42)
+  assert.equal(parsed.voice, 'spoken note')
+})
+
+test('RunStore enqueues document, voice, and approval items properly', async () => fixture(async (store) => {
+  const created = await store.create({ chatId: 1, telegramUserId: 1, texts: ['test'] })
+  await store.patch(created.id, { status: 'running' })
+
+  const docItem = await store.enqueueDocument(created.id, './report.pdf', { caption: 'Here is your report', replyToMessageId: 42 })
+  assert.equal(docItem.type, 'document')
+  assert.equal(docItem.documentPath, './report.pdf')
+  assert.equal(docItem.text, 'Here is your report')
+  assert.equal(docItem.replyToMessageId, 42)
+
+  const voiceItem = await store.enqueueVoice(created.id, 'Hello in audio', { replyToMessageId: 42 })
+  assert.equal(voiceItem.type, 'voice')
+  assert.equal(voiceItem.voiceText, 'Hello in audio')
+
+  const appItem = await store.enqueueApproval(created.id, 'Approve transaction?', 'tx_123', { replyToMessageId: 42 })
+  assert.equal(appItem.type, 'approval')
+  assert.equal(appItem.approvalPrompt, 'Approve transaction?')
+  assert.equal(appItem.approvalActionId, 'tx_123')
+
+  const pending = await store.pendingOutbox()
+  assert.equal(pending.length, 3)
+}))
+
+test('claimOutbox prevents concurrent double-processing of the same item', async () => fixture(async (store) => {
+  const created = await store.create({ chatId: 1, telegramUserId: 1, texts: ['test'] })
+  await store.patch(created.id, { status: 'running' })
+  const item = await store.enqueueMessage(created.id, 'one copy only')
+
+  // First claim succeeds
+  const firstClaim = await store.claimOutbox(item.id)
+  assert.equal(firstClaim, true)
+
+  // Item is no longer visible in pendingOutbox while claimed (.sending.json)
+  assert.equal((await store.pendingOutbox()).length, 0)
+
+  // Concurrent second claim must fail
+  const secondClaim = await store.claimOutbox(item.id)
+  assert.equal(secondClaim, false)
+
+  // Mark sent renames to .sent.json
+  await store.markOutboxSent(item.id)
+  assert.equal((await store.pendingOutbox()).length, 0)
+}))
+
+test('unclaimOutbox restores item for retry on transient failure', async () => fixture(async (store) => {
+  const created = await store.create({ chatId: 1, telegramUserId: 1, texts: ['test'] })
+  await store.patch(created.id, { status: 'running' })
+  const item = await store.enqueueMessage(created.id, 'retry item')
+
+  assert.equal(await store.claimOutbox(item.id), true)
+  assert.equal((await store.pendingOutbox()).length, 0)
+
+  await store.unclaimOutbox(item.id)
+  assert.equal((await store.pendingOutbox()).length, 1)
+}))

package/test/security.test.ts

@@ -0,0 +1,85 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile, symlink, mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { isOwner } from '../src/identity.js'
+import { RunStore } from '../src/runs.js'
+import { ApprovalStore } from '../src/approval.js'
+import { ControlStore } from '../src/control-state.js'
+import { stageIncomingFile, workspaceFile, detectFileType } from '../src/files.js'
+import { EXECUTOR_REGISTRY } from '../src/executor.js'
+
+test('owner gate denies groups, bots, missing identity, and a different sender or chat', () => {
+  const owner = { telegramUserId: 101, telegramChatId: 101, pairedAt: '' }
+  const from = { id: 101, is_bot: false, first_name: 'Test' }
+  const chat = { id: 101, type: 'private' as const, first_name: 'Test' }
+  assert.ok(isOwner({ from, chat }, owner))
+  for (const input of [
+    { from: undefined, chat },
+    { from: { ...from, id: 202 }, chat },
+    { from: { ...from, is_bot: true }, chat },
+    { from, chat: { ...chat, id: 202 } },
+    { from, chat: { id: -101, type: 'group' as const, title: 'Test' } },
+  ])
+    assert.equal(isOwner(input, owner), false)
+  assert.equal(isOwner({ from, chat }, null), false)
+})
+
+test('store identifiers reject traversal; corrupt records cannot authorize or block healthy runs', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-negative-'))
+  try {
+    const runs = new RunStore(dir)
+    await assert.rejects(runs.get('../control-state'), /Invalid/)
+    await assert.rejects(runs.claimOutbox('../control-state'), /Invalid/)
+    await assert.rejects(new ApprovalStore(dir).getDecision('../escape'), /Invalid/)
+    const run = await runs.create({ chatId: 101, telegramUserId: 101, texts: ['test'] })
+    await writeFile(join(dir, 'runs', 'broken.json'), '{')
+    assert.equal((await runs.nextQueued())?.id, run.id)
+    await writeFile(join(dir, 'control-state.json'), '{')
+    await assert.rejects(new ControlStore(dir, 1000).status())
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('approval decisions cannot be invented, replayed or reused for another action', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-approval-negative-'))
+  try {
+    const approvals = new ApprovalStore(dir)
+    await assert.rejects(approvals.recordDecision('missing', 'approved', 101), /Unknown/)
+    await approvals.requestApproval('sample', 'A harmless test?', 'run_a')
+    await assert.rejects(approvals.requestApproval('sample', 'Different?', 'run_b'), /another request/)
+    await approvals.recordDecision('sample', 'denied', 101)
+    await assert.rejects(approvals.recordDecision('sample', 'approved', 101), /already decided/)
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('files reject malformed UTF-8 and symlinks outside the workspace', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-path-negative-'))
+  try {
+    const workspace = join(dir, 'workspace')
+    await mkdir(workspace)
+    await writeFile(join(dir, 'private.txt'), 'private')
+    await symlink(join(dir, 'private.txt'), join(workspace, 'escape.txt'))
+    await assert.rejects(workspaceFile(workspace, 'escape.txt'), /outside/)
+    assert.equal(detectFileType(Buffer.from([0xff, 0xfe, 0x41])), 'unknown')
+    await assert.rejects(stageIncomingFile(workspace, 'bad.txt', Buffer.from([0xff, 0xfe])), /Unsupported/)
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('Grok uses an exact session for continuation and a distinct fresh session for new', () => {
+  const build = EXECUTOR_REGISTRY.grok.buildArgs
+  assert.deepEqual(
+    build({ workspace: '/tmp', sessionId: 'test', isResume: true }, '/tmp/p', '').slice(0, 2),
+    ['--resume', 'test'],
+  )
+  assert.deepEqual(
+    build({ workspace: '/tmp', sessionId: 'new', isResume: false }, '/tmp/p', '').slice(0, 2),
+    ['--session-id', 'new'],
+  )
+})

package/test/setup.test.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { mkdtemp, rm, readFile, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { findExecutableInPath, readActiveExecutor, setExecutorInEnv, getExecutorsStatus } from '../src/setup.js'
+
+test('findExecutableInPath locates existing binary and returns null for nonexistent', async () => {
+  const nodePath = await findExecutableInPath('node', process.env.PATH)
+  assert.ok(nodePath && nodePath.includes('node'))
+
+  const missing = await findExecutableInPath('nonexistent-binary-12345', process.env.PATH)
+  assert.equal(missing, null)
+})
+
+test('readActiveExecutor extracts EZ_EXECUTOR_CLI or defaults to agy', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'ez-setup-test-'))
+  try {
+    const envPath = path.join(dir, '.env')
+    assert.equal(await readActiveExecutor(envPath), 'agy')
+
+    await writeFile(envPath, 'EZ_EXECUTOR_CLI=claude\n', 'utf8')
+    assert.equal(await readActiveExecutor(envPath), 'claude')
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('setExecutorInEnv updates or adds EZ_EXECUTOR_CLI without altering other env lines', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'ez-setup-test-'))
+  try {
+    const envPath = path.join(dir, '.env')
+    await writeFile(envPath, 'TELEGRAM_BOT_TOKEN=token123\nEZ_AGENT_WORKSPACE=./agent\n', 'utf8')
+
+    await setExecutorInEnv(envPath, 'claude')
+    let content = await readFile(envPath, 'utf8')
+    assert.match(content, /TELEGRAM_BOT_TOKEN=token123/)
+    assert.match(content, /EZ_EXECUTOR_CLI=claude/)
+
+    await setExecutorInEnv(envPath, 'antigravity')
+    content = await readFile(envPath, 'utf8')
+    assert.match(content, /TELEGRAM_BOT_TOKEN=token123/)
+    assert.match(content, /EZ_EXECUTOR_CLI=antigravity/)
+    assert.ok(!content.includes('claude'))
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('getExecutorsStatus returns all executors and sets isActive correctly', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'ez-setup-test-'))
+  try {
+    const envPath = path.join(dir, '.env')
+    await writeFile(envPath, 'EZ_EXECUTOR_CLI=claude\n', 'utf8')
+
+    const status = await getExecutorsStatus(envPath)
+    assert.equal(status.active, 'claude')
+    const claudeItem = status.items.find((item) => item.id === 'claude')
+    assert.ok(claudeItem)
+    assert.equal(claudeItem.isActive, true)
+
+    const agyItem = status.items.find((item) => item.id === 'agy')
+    assert.ok(agyItem)
+    assert.equal(agyItem.isActive, false)
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})