A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.
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)
})