Skip to content

A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.

25.0 KB
Raw Blame
import assert from 'node:assert/strict'
import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { test } from 'node:test'
import { apply, createRuntime } from '../index.js'
import { defaultBrowserHeadless } from '../src/host/browser-plugins.js'
import { gateScope } from '../src/host/browser/gate.js'
import { appBrowserEndpoint } from '../src/host/browser-plugins.js'
import { mountBrowserPlugin } from '../src/host/browser/mount.js'
import { systemPrompt as refsPrompt, toolDefs as refsTools } from '../src/host/browser/refs.js'
import { fakeApproval, fakeContext } from './fake-ctx.js'

const TEAM = {
  version: 1,
  mainBotId: 'm1',
  revision: 1,
  bots: {
    m1: { id: 'm1', sessionId: 'm1', name: 'Chief', role: 'Chief of Staff', lab: 'deepseek', instructions: '', createdAt: 1 },
    b2: { id: 'b2', sessionId: 'b2', name: 'Writer', role: '写作', instructions: '', createdAt: 2 },
  },
  rooms: {},
  exchanges: [],
  exchangeTurns: {},
  questions: {},
}

let rt
function start(config, { services = {}, team = TEAM } = {}) {
  const home = mkdtempSync(join(tmpdir(), 'ds-bot-browser-plugin-'))
  writeFileSync(join(home, 'state.json'), JSON.stringify(team))
  const ctx = fakeContext({ services })
  let route
  const register = ctx.connection.fetch.register
  ctx.connection.fetch.register = options => {
    route = options
    return register(options)
  }
  rt = createRuntime(ctx, { home, ...config })
  return {
    ctx,
    rt,
    call: async (endpoint, payload) => {
      const response = await route.fetch(new Request('http://localhost/api/bot', {
        method: 'POST',
        body: JSON.stringify({ endpoint, payload }),
      }))
      return response.json()
    },
    stop: () => {
      rmSync(home, { recursive: true, force: true })
    },
  }
}

const WRITE_ACTION = {
  kind: 'post',
  label: 'Publish update',
  origin: 'https://shop.example.com',
  host: 'shop.example.com',
}

function browserWriter() {
  let runs = 0
  let action = WRITE_ACTION
  return {
    runs: () => runs,
    setAction: value => { action = value },
    plugin: {
      id: 'refs',
      tools: [{
        name: 'browser_write',
        needsBrowser: false,
        async execute() {
          await gateScope.getStore()?.(action)
          runs += 1
          return 'written'
        },
      }],
    },
  }
}

const permissionService = defaultPreset => ({
  catalog: () => ({ options: [], defaultPreset }),
})

function browserExec(botId = 'b2', sessionId = botId) {
  return {
    name: 'browser_write',
    callId: 'call-1',
    signal: new AbortController().signal,
    agent: { id: botId, session: { header: { id: sessionId } } },
  }
}

test('app browser endpoint carries download roots for the Bot resolved from the exec', async () => {
  const originalSend = process.send
  const roots = ['/workspace/b2', '/workspace']
  let request
  const tools = new Map()
  let cleanup
  process.send = (message, callback) => {
    request = message
    callback?.()
    queueMicrotask(() => process.emit('message', {
      type: 'ds-bot:browser-endpoint-response',
      id: message.id,
      url: 'ws://127.0.0.1:1234/devtools/browser/token',
    }))
    return true
  }
  try {
    mountBrowserPlugin({
      on() {},
      effect(create) { cleanup = create() },
      tools: { register(tool) { tools.set(tool.name, tool) } },
    }, {
      toolDefs: [{ name: 'browser_open', needsBrowser: true, execute: () => 'opened' }],
      defineTool: value => value,
      keyOf: async exec => exec.agent.id,
      profileRoot: '/profiles',
      downloadRoot: '/legacy-downloads',
      downloadRoots: async botId => {
        assert.equal(botId, 'b2')
        return roots
      },
      uploadRoots: async botId => {
        assert.equal(botId, 'b2')
        return roots
      },
      headless: true,
      connect: appBrowserEndpoint,
      openSession: async options => {
        assert.equal(options.botId, 'b2')
        assert.equal(await options.downloadDir(), roots[0])
        assert.deepEqual(await options.uploadRoots(), roots)
        await options.connect(options.botId)
        return { close: async () => {} }
      },
    })
    const result = await tools.get('browser_open').execute({ botId: 'other' }, { agent: { id: 'b2' } })
    assert.deepEqual(request, {
      type: 'ds-bot:browser-endpoint',
      id: request.id,
      botId: 'b2',
      downloadRoots: roots,
    })
    assert.equal(result, 'opened')
  } finally {
    await cleanup?.()
    process.send = originalSend
  }
})

test('concurrent first browser calls share opening and relay connection', async () => {
  const tools = new Map()
  let cleanup
  let releaseOpen
  const waitForOpen = new Promise(resolve => { releaseOpen = resolve })
  let openCalls = 0
  let connectCalls = 0
  let rootsCalls = 0
  mountBrowserPlugin({
    on() {},
    effect(create) { cleanup = create() },
    tools: { register(tool) { tools.set(tool.name, tool) } },
  }, {
    toolDefs: [{ name: 'browser_open', needsBrowser: true, execute: () => 'opened' }],
    defineTool: value => value,
    keyOf: async () => 'b2',
    profileRoot: '/profiles',
    downloadRoots: async () => {
      rootsCalls += 1
      return ['/workspace/b2', '/workspace']
    },
    headless: true,
    connect: async () => {
      connectCalls += 1
      return 'ws://127.0.0.1:1234/devtools/browser/token'
    },
    openSession: async options => {
      openCalls += 1
      await options.connect(options.botId)
      await waitForOpen
      return { close: async () => {} }
    },
  })

  const execute = () => tools.get('browser_open').execute({}, { agent: { id: 'b2' } })
  const first = execute()
  const second = execute()
  await new Promise(resolve => setImmediate(resolve))

  assert.equal(openCalls, 1)
  assert.equal(connectCalls, 1)
  assert.equal(rootsCalls, 1)

  releaseOpen()
  assert.deepEqual(await Promise.all([first, second]), ['opened', 'opened'])
  await cleanup?.()
})

test('user takeover while opening closes the session once it resolves', async () => {
  const tools = new Map()
  let cleanup
  let publishHold
  let startedOpening
  let releaseOpen
  let resolveClosed
  let closeCalls = 0
  const openingStarted = new Promise(resolve => { startedOpening = resolve })
  const waitForOpen = new Promise(resolve => { releaseOpen = resolve })
  const closed = new Promise(resolve => { resolveClosed = resolve })
  let hold = null
  mountBrowserPlugin({
    on() {},
    effect(create) { cleanup = create() },
    tools: { register(tool) { tools.set(tool.name, tool) } },
  }, {
    toolDefs: [{ name: 'browser_open', needsBrowser: true, execute: () => 'opened' }],
    defineTool: value => value,
    keyOf: async () => 'b2',
    profileRoot: '/profiles',
    headless: true,
    getHold: () => hold,
    subscribeHolds: listener => {
      publishHold = listener
      return () => {}
    },
    openSession: () => {
      startedOpening()
      return waitForOpen
    },
  })

  const opening = tools.get('browser_open').execute({}, { agent: { id: 'b2' } })
  await openingStarted
  hold = { by: 'user' }
  publishHold('b2', hold)
  releaseOpen({ close: async () => { closeCalls += 1; resolveClosed() } })
  await opening
  await closed
  assert.equal(closeCalls, 1)
  await cleanup?.()
})

test('user takeover refuses a browser call before opening or connecting', async () => {
  const tools = new Map()
  let openCalls = 0
  let connectCalls = 0
  mountBrowserPlugin({
    on() {},
    effect() {},
    tools: { register(tool) { tools.set(tool.name, tool) } },
  }, {
    toolDefs: [{ name: 'browser_open', needsBrowser: true, execute: () => 'opened' }],
    defineTool: value => value,
    keyOf: async () => 'b2',
    profileRoot: '/profiles',
    headless: true,
    getHold: () => ({ by: 'user' }),
    connect: async () => {
      connectCalls += 1
      return 'ws://127.0.0.1:1234/devtools/browser/token'
    },
    openSession: async () => {
      openCalls += 1
      return { close: async () => {} }
    },
  })

  await assert.rejects(
    tools.get('browser_open').execute({}, { agent: { id: 'b2' } }),
    /The user has taken over this browser/,
  )
  assert.equal(openCalls, 0)
  assert.equal(connectCalls, 0)
})

test('no browser plugin is mounted unless one is selected for the team', (t) => {
  const { ctx, stop } = start({})
  t.after(stop)
  assert.equal(ctx.calls.includes('effect ds-bot: browser plugin'), false)
  assert.equal(rt.teamTools.some(d => d.name === 'browser_open'), false)
  assert.equal(rt.teamTools.some(d => d.name === 'browser_exec'), false)
  assert.equal(rt.teamTools.some(d => d.name === 'browser_task'), false)
})

test('user browser controls are not exposed as Bot tools', (t) => {
  const { stop } = start({ browser: true, browserPlugin: 'refs' })
  t.after(stop)
  for (const name of ['browser-takeover', 'browser-give-back', 'browser-stop']) {
    assert.equal(rt.teamTools.some(d => d.name === name), false)
  }
})

test('browser-stop cancels the Bot chat, stops its room work, and sets a user hold', async (t) => {
  const { rt, call, stop } = start({ browser: true })
  t.after(stop)
  await rt.load()

  rt.state.rooms.room1 = { id: 'room1', members: ['b2'], sessions: { b2: 'room-session' } }
  rt.state.rooms.room2 = { id: 'room2', members: ['m1'], sessions: { m1: 'other-session' } }
  rt.live.set('b2', { turn: {} })
  rt.live.set('room-session', { turn: {} })
  const cancelled = []
  const stoppedRooms = []
  rt.resolveAgent = async sessionId => ({ cancel: reason => cancelled.push({ sessionId, reason }) })
  rt.stopMemberWork = async (roomId, botId) => { stoppedRooms.push({ roomId, botId }) }

  assert.equal((await call('browser-stop', { botId: 'b2' })).value, true)
  assert.deepEqual(cancelled, [{ sessionId: 'b2', reason: { kind: 'user' } }])
  assert.deepEqual(stoppedRooms, [{ roomId: 'room1', botId: 'b2' }])
  assert.deepEqual(rt.browserChannel.holdOf('b2'), {
    by: 'user', reason: 'stopped', note: 'The user is controlling this browser.',
  })
})

test('browser headless defaults only on Linux without a display', () => {
  assert.equal(defaultBrowserHeadless('linux', { DISPLAY: ':0' }), false)
  assert.equal(defaultBrowserHeadless('linux', {}), true)
  assert.equal(defaultBrowserHeadless('darwin', {}), false)
})

test('browser_task uses the Bot session model route when no test completion is injected', async (t) => {
  const { ctx, stop } = start({
    browserPlugin: 'task',
    browserPluginApi: {
      id: 'task',
      tools: [{
        name: 'browser_task',
        needsBrowser: false,
        async execute(_args, toolCtx) {
          const response = await toolCtx.complete({
            messages: [{ role: 'user', content: 'Read the page.' }],
            tools: [{
              type: 'function',
              function: { name: 'browser_snapshot', description: 'Read page', parameters: { type: 'object' } },
            }],
          })
          return response.choices[0].message.content
        },
      }],
    },
  })
  t.after(stop)
  const requests = []
  ctx.llm = {
    async *stream(request) {
      requests.push(request)
      yield { type: 'text-delta', index: 0, text: 'Session-routed response.' }
      yield { type: 'finish', reason: { kind: 'stop' } }
    },
  }
  const session = {
    id: 'session-b2',
    header: { id: 'b2' },
    requestHeader: () => ({
      config: { provider: 'mock-provider', model: 'bot-session-model' },
      tools: [{ name: 'session-private-tool', description: '', parameters: {} }],
    }),
  }

  const value = await rt.teamTools.find(d => d.name === 'browser_task').execute({}, {
    agent: { id: 'b2', session },
    signal: new AbortController().signal,
  })

  assert.equal(value, 'Session-routed response.')
  assert.equal(requests[0].model, 'bot-session-model')
  assert.equal(requests[0].sessionId, 'session-b2')
  assert.deepEqual(requests[0].tools.map(tool => tool.name), ['browser_snapshot'])
})

test('the selected plugin is the same for every Bot, and profiles stay apart', async (t) => {
  const seen = []
  const { ctx, stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: {
      id: 'refs',
      tools: [
        {
          name: 'browser_snapshot',
          description: 'Read the page',
          parameters: {},
          async execute(_args, toolCtx) {
            seen.push(toolCtx.botId)
            return toolCtx.profileDir
          },
        },
      ],
    },
  })
  t.after(stop)
  assert.ok(ctx.calls.includes('effect ds-bot: browser plugin'))
  const tool = rt.teamTools.find(d => d.name === 'browser_snapshot')
  const writer = await tool.execute({}, { agent: { id: 'b2' } })
  const chief = await tool.execute({}, { agent: { id: 'm1' } })
  assert.deepEqual(seen, ['b2', 'm1'])
  assert.ok(writer.endsWith(join('browser-profiles', 'b2')))
  assert.ok(chief.endsWith(join('browser-profiles', 'm1')))
  assert.equal(await tool.execute({}, { agent: { id: 'stranger' } }), 'Only Bots on the team have a browser.')
})

test('an unknown browser plugin is refused', () => {
  const home = mkdtempSync(join(tmpdir(), 'ds-bot-browser-plugin-'))
  try {
    assert.throws(() => createRuntime(fakeContext(), { home, browserPlugin: 'devtools' }), /Choose refs, script, task/)
  } finally {
    rmSync(home, { recursive: true, force: true })
  }
})

test('refs exposes the ARIA snapshot tool contract', () => {
  assert.deepEqual(refsTools.map(tool => tool.name), [
    'browser_open',
    'browser_snapshot',
    'browser_click',
    'browser_upload',
    'browser_type',
    'browser_select',
    'browser_press',
    'browser_tabs',
    'browser_back',
    'browser_screenshot',
    'browser_handoff',
    'browser_resume',
  ])
  assert.equal(refsTools.some(tool => tool.name === 'browser_scroll'), false)
  assert.equal(refsTools.find(tool => tool.name === 'browser_type').parameters.submit.required, undefined)
  assert.equal(refsTools.find(tool => tool.name === 'browser_tabs').parameters.index.required, undefined)
  assert.equal(refsTools.find(tool => tool.name === 'browser_handoff').parameters.note.required, undefined)
  assert.ok(refsPrompt.includes('Posting, uploading, downloading, or deleting may need approval;'))
})

test('browserExecutablePath must be a string when configured', () => {
  const home = mkdtempSync(join(tmpdir(), 'ds-bot-browser-plugin-'))
  try {
    assert.throws(
      () => apply(fakeContext(), { home, browserPlugin: 'refs', browserExecutablePath: 42 }),
      /browserExecutablePath must be a string/,
    )
  } finally {
    rmSync(home, { recursive: true, force: true })
  }
})

test('a matching browser grant allows the write without asking', async (t) => {
  const approval = fakeApproval('rejected')
  const writer = browserWriter()
  const team = structuredClone(TEAM)
  team.bots.b2.browserGrants = [{ site: 'example.com', kinds: ['post'] }]
  const { stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: writer.plugin,
  }, { services: { approval, permissionPresets: permissionService('workspace-write') }, team })
  t.after(stop)

  assert.equal(await rt.teamTools.find(d => d.name === 'browser_write').execute({}, browserExec()), 'written')
  assert.equal(writer.runs(), 1)
  assert.equal(approval.requests.length, 0)
})

test('approval is one-shot and each write requests it again', async (t) => {
  const approval = fakeApproval('allowed-once')
  const writer = browserWriter()
  const { stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: writer.plugin,
  }, { services: { approval, permissionPresets: permissionService('workspace-write') } })
  t.after(stop)
  const tool = rt.teamTools.find(d => d.name === 'browser_write')

  assert.equal(await tool.execute({}, browserExec()), 'written')
  assert.equal(await tool.execute({}, browserExec()), 'written')
  assert.equal(writer.runs(), 2)
  assert.equal(approval.requests.length, 2)
  assert.match(approval.requests[0].reason, /shop\.example\.com/)
  assert.match(approval.requests[0].reason, /Publish update/)
  assert.equal(approval.requests[0].toolName, 'browser_write')
  assert.equal(approval.requests[0].callId, 'call-1')
  assert.match(approval.requests[0].displayReason.en, /^Let Writer post/)
  assert.match(approval.requests[0].displayReason.zh, /Writer/)
})

test('a rejected approval prevents the write', async (t) => {
  const approval = fakeApproval('rejected')
  const writer = browserWriter()
  const { stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: writer.plugin,
  }, { services: { approval, permissionPresets: permissionService('workspace-write') } })
  t.after(stop)

  await assert.rejects(rt.teamTools.find(d => d.name === 'browser_write').execute({}, browserExec()), /Do not try this action again unless the user asks\..*Nothing was done\./)
  assert.equal(writer.runs(), 0)
})

test('browser grants match exact hosts, subdomains, and wildcard sites and kinds', async (t) => {
  const cases = [
    { site: 'example.com', host: 'shop.example.com', kinds: ['post'], allowed: true },
    { site: 'example.com', host: 'badexample.com', kinds: ['post'], allowed: false },
    { site: '*', host: 'unrelated.test', kinds: ['post'], allowed: true },
    { site: 'example.com', host: 'example.com', kinds: ['*'], allowed: true },
  ]
  for (const entry of cases) {
    const approval = fakeApproval('rejected')
    const writer = browserWriter()
    const team = structuredClone(TEAM)
    team.bots.b2.browserGrants = [{ site: entry.site, kinds: entry.kinds }]
    const { stop } = start({
      browserPlugin: 'refs',
      browserPluginApi: writer.plugin,
    }, { services: { approval, permissionPresets: permissionService('workspace-write') }, team })
    t.after(stop)
    const action = { ...WRITE_ACTION, host: entry.host }
    writer.setAction(action)
    const tool = rt.teamTools.find(d => d.name === 'browser_write')
    if (entry.allowed) {
      assert.equal(await tool.execute({}, browserExec()), 'written')
      assert.equal(approval.requests.length, 0)
    } else {
      await assert.rejects(tool.execute({}, browserExec()), /Nothing was done\./)
      assert.equal(approval.requests.length, 1)
    }
    await stop()
  }
})

test('read-only permissions use the ordinary approval path', async (t) => {
  const approval = fakeApproval('allowed-once')
  const writer = browserWriter()
  const team = structuredClone(TEAM)
  team.bots.b2.permission = 'read-only'
  const { stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: writer.plugin,
  }, { services: { approval, permissionPresets: permissionService('workspace-write') }, team })
  t.after(stop)
  assert.equal(await rt.teamTools.find(d => d.name === 'browser_write').execute({}, browserExec()), 'written')
  assert.equal(writer.runs(), 1)
  assert.equal(approval.requests.length, 1)
})

test('missing approval service is reported without running the write', async (t) => {
  const writer = browserWriter()
  const { stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: writer.plugin,
  }, { services: { permissionPresets: permissionService('workspace-write') } })
  t.after(stop)

  await assert.rejects(rt.teamTools.find(d => d.name === 'browser_write').execute({}, browserExec()), /needs the user's approval.*so nothing was done\./)
  assert.equal(writer.runs(), 0)
})

test('approval cancellation, service failure, and missing Sessions are explicit', async (t) => {
  const cases = [
    {
      approval: fakeApproval('cancelled'),
      exec: browserExec(),
      message: /approval was cancelled\. Nothing was done\./,
    },
    {
      approval: { async request() { throw new Error('service offline') } },
      exec: browserExec(),
      message: /approval service was unavailable\. Nothing was done\./,
    },
    {
      approval: fakeApproval('allowed-once'),
      exec: { name: 'browser_write', agent: { id: 'b2' } },
      message: /needs the user's approval.*no way to ask here, so nothing was done\./,
    },
  ]
  for (const entry of cases) {
    const writer = browserWriter()
    const { stop } = start({
      browserPlugin: 'refs',
      browserPluginApi: writer.plugin,
    }, { services: { approval: entry.approval, permissionPresets: permissionService('workspace-write') } })
    t.after(stop)
    await assert.rejects(rt.teamTools.find(d => d.name === 'browser_write').execute({}, entry.exec), entry.message)
    assert.equal(writer.runs(), 0)
  }
})

test('approval verbs cover every gated action', async (t) => {
  const approval = fakeApproval('allowed-once')
  const writer = browserWriter()
  const { stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: writer.plugin,
  }, { services: { approval, permissionPresets: permissionService('workspace-write') } })
  t.after(stop)
  const tool = rt.teamTools.find(d => d.name === 'browser_write')
  for (const [kind, label, verb] of [
    ['post', 'Publish update', 'post'],
    ['upload', 'upload files', 'upload files'],
    ['download', 'download file', 'download a file'],
    ['delete', 'Delete item', 'delete something'],
  ]) {
    writer.setAction({ ...WRITE_ACTION, kind, label })
    assert.equal(await tool.execute({}, browserExec()), 'written')
    assert.match(approval.requests.at(-1).reason, new RegExp(verb))
  }
})

test('payment is refused even with a wildcard grant or full-access preset', async (t) => {
  for (const setup of [
    team => { team.bots.b2.browserGrants = [{ site: '*', kinds: ['*'] }] },
    team => { team.bots.b2.permission = 'danger-full-access' },
  ]) {
    const approval = fakeApproval('allowed-once')
    const writer = browserWriter()
    const team = structuredClone(TEAM)
    setup(team)
    writer.setAction({ ...WRITE_ACTION, kind: 'payment', label: 'Pay now' })
    const { stop } = start({
      browserPlugin: 'refs',
      browserPluginApi: writer.plugin,
    }, { services: { approval, permissionPresets: permissionService('workspace-write') }, team })
    t.after(stop)
    await assert.rejects(
      rt.teamTools.find(d => d.name === 'browser_write').execute({}, browserExec()),
      /call browser_handoff with reason "payment".*Nothing was done\./,
    )
    assert.equal(writer.runs(), 0)
    assert.equal(approval.requests.length, 0)
  }
})

test('expired grants do not authorize a write', async (t) => {
  const approval = fakeApproval('allowed-once')
  const writer = browserWriter()
  const team = structuredClone(TEAM)
  team.bots.b2.browserGrants = [{ site: 'example.com', kinds: ['post'], until: Date.now() - 1 }]
  const { stop } = start({
    browserPlugin: 'refs',
    browserPluginApi: writer.plugin,
  }, { services: { approval, permissionPresets: permissionService('workspace-write') }, team })
  t.after(stop)
  assert.equal(await rt.teamTools.find(d => d.name === 'browser_write').execute({}, browserExec()), 'written')
  assert.equal(writer.runs(), 1)
  assert.equal(approval.requests.length, 1)
})

test('browser grants are user-only, normalized, deduplicated, expiring, and clearable through api/bot', async (t) => {
  const { rt, call, stop } = start({})
  t.after(stop)
  await rt.load()
  await assert.rejects(
    rt.updateBot('b2', { browserGrants: [] }, 'b2'),
    { message: 'Only the user can set what Writer may do in the browser' },
  )
  await assert.rejects(
    rt.updateBot('b2', { browserGrants: [{ site: 'https://example.com/path', kinds: ['post'] }] }),
    /Browser grant site must be \* or a hostname/,
  )
  await assert.rejects(
    rt.updateBot('b2', { browserGrants: [{ site: 'example.com', kinds: ['post', 'unsafe'] }] }),
    /Browser grant kinds must be a non-empty subset/,
  )
  for (const legacy of ['submit', 'purchase']) {
    await assert.rejects(
      rt.updateBot('b2', { browserGrants: [{ site: 'example.com', kinds: [legacy] }] }),
      /Browser grant kinds must be a non-empty subset/,
    )
  }
  for (const until of ['later', Number.NaN, Infinity]) {
    await assert.rejects(
      rt.updateBot('b2', { browserGrants: [{ site: '*', kinds: ['post'], until }] }),
      /future epoch-millisecond timestamp/,
    )
  }
  const expiredGrant = { site: '*', kinds: ['post'], until: Date.now() - 1 }
  const expired = await call('update-bot', { id: 'b2', browserGrants: [expiredGrant] })
  assert.equal(expired.ok, true)
  assert.deepEqual(expired.value.browserGrants, [])
  const freshGrant = { site: 'fresh.example', kinds: ['delete'], until: Date.now() + 60_000 }
  const mixed = await call('update-bot', { id: 'b2', browserGrants: [expiredGrant, freshGrant] })
  assert.equal(mixed.ok, true)
  assert.deepEqual(mixed.value.browserGrants, [
    { site: 'fresh.example', kinds: ['delete'], until: freshGrant.until },
  ])
  await assert.rejects(
    rt.updateBot('b2', { browserGrants: Array.from({ length: 51 }, () => ({ site: '*', kinds: ['*'] })) }),
    /array of at most 50 entries/,
  )
  const saved = await call('update-bot', {
    id: 'b2',
    browserGrants: [
      { site: ' Example.COM ', kinds: ['post', 'upload', 'download', 'delete', 'post'] },
      { site: 'example.com', kinds: ['post', 'upload', 'download', 'delete'], until: Date.now() + 60_000 },
    ],
  })
  assert.equal(saved.ok, true)
  assert.deepEqual(saved.value.browserGrants, [
    { site: 'example.com', kinds: ['delete', 'download', 'post', 'upload'] },
    { site: 'example.com', kinds: ['delete', 'download', 'post', 'upload'], until: saved.value.browserGrants[1].until },
  ])
  const cleared = await call('update-bot', { id: 'b2', browserGrants: null })
  assert.equal(cleared.ok, true)
  assert.equal(Object.hasOwn(cleared.value, 'browserGrants'), false)
})