ds-harness-remote-fast/apps/android/tests/bot-catalog.test.ts

266 lines
18 KiB
TypeScript

import { AbortController as NativeAbortController } from 'abort-controller'
import { describe, expect, it, vi } from 'vitest'
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
import {
BotRemoteClient,
botMessageRequest,
canDeleteBot,
isScopedKnownBotSessionId,
parseBotState,
trackScopedBotStateSessions,
type BotOperation,
} from '../src/services/bot-catalog'
import { inboxQueuedItems } from '../src/state/message-helpers'
import { buildBotMentionRows, buildReferenceChatGroups, insertReferenceAtSelection } from '../src/screens/bot/at-menu'
import { sessionMentionText } from '../src/ui/mention-helpers'
import type { RemoteSession } from '../src/types'
const botState = () => ({ bots: [{ id: 'bot', sessionId: 'part-2', name: 'Bot' }], rooms: [{ id: 'room', name: 'Team', members: ['bot', 'other'] }], mainBotIds: ['bot'] })
const envelope = (value: unknown) => ({ status: 200, json: { ok: true, value } })
const session = (sessionId: string, backend?: RemoteSession['backend']): RemoteSession => ({ sessionId, backend, updatedAt: 1, running: false, blank: false })
describe('Android Bot client authority', () => {
it('supports React Native cancellation before dispatch and after asynchronous responses', async () => {
await runScenarios(['active', 'before', 'during-state', 'during-catalog'].map(stage => ({ name: stage, run: async () => {
const controller = new NativeAbortController()
const signal = controller.signal as AbortSignal
const dispatch = vi.fn(async () => {
if (stage === 'during-state') controller.abort()
return envelope(botState())
})
const readSessions = vi.fn(async () => {
if (stage === 'during-catalog') controller.abort()
return [session('part-2')]
})
const client = new BotRemoteClient(dispatch, readSessions, () => {})
if (stage === 'before') controller.abort()
if (stage === 'active') await expect(client.resolveSession('bot', signal)).resolves.toMatchObject({ session: { sessionId: 'part-2' } })
else await expect(client.resolveSession('bot', signal)).rejects.toMatchObject({ name: 'AbortError' })
expect(dispatch).toHaveBeenCalledTimes(stage === 'before' ? 0 : 1)
expect(readSessions).toHaveBeenCalledTimes(stage === 'active' || stage === 'during-catalog' ? 1 : 0)
} })))
})
it('claims side questions without ever falling back to a queued prompt', async () => {
await runScenarios([
{ name: 'aside', draft: '/btw progress?', target: 'bot', supported: true, endpoint: 'btw', text: 'progress?' },
{ name: 'multiline', draft: ' /btw\nprogress? ', target: 'bot', supported: true, endpoint: 'btw', text: 'progress?' },
{ name: 'empty aside', draft: '/btw ', target: 'bot', supported: true },
{ name: 'group aside', draft: '/btw progress?', target: 'room', supported: true },
{ name: 'older Bot', draft: '/btw progress?', target: 'bot', supported: false },
{ name: 'ordinary message on older Bot', draft: 'hello', target: 'bot', supported: false, endpoint: 'send', text: 'hello' },
{ name: 'not the command', draft: '/btwquestion', target: 'bot', supported: true, endpoint: 'send', text: '/btwquestion' },
{ name: 'bot sessionId target', draft: 'hello', target: 'part-2', supported: true, endpoint: 'send', expectedSessionId: 'bot', text: 'hello' },
{ name: 'agent session target', draft: 'hello agent', target: 'agent-s1', supported: true, endpoint: 'send', expectedSessionId: 'agent-s1', text: 'hello agent' },
{ name: 'aside on agent session rejected', draft: '/btw progress?', target: 'agent-s1', supported: true },
{ name: 'read only', draft: '/btw progress?', target: 'bot', supported: true, readOnly: 'locked' },
{ name: 'unknown session', draft: '/btw progress?', target: 'unlisted', supported: true },
].map(row => ({ name: row.name, run: async () => {
const state = parseBotState({
...botState(),
agents: [{ id: 'agent-1', sessions: ['agent-s1'] }],
...(row.supported ? { btwCards: {} } : {}),
readOnly: row.readOnly,
})
const dispatch = vi.fn(async () => envelope({ id: 'aside' }))
const client = new BotRemoteClient(dispatch, async () => [], () => {})
const send = async () => {
const request = botMessageRequest(state, row.target, row.draft)
return client.call(request.endpoint, request.payload)
}
if (row.endpoint) {
await send()
expect(dispatch).toHaveBeenCalledTimes(1)
expect(dispatch).toHaveBeenCalledWith(
{ endpoint: row.endpoint, payload: { sessionId: row.expectedSessionId ?? row.target, text: row.text } },
undefined,
)
} else { await expect(send()).rejects.toThrow(); expect(dispatch).not.toHaveBeenCalled() }
} })))
// Unknown outcome is never retried as either a side question or a prompt.
const dispatch = vi.fn(async () => { throw new Error('disconnected') })
const client = new BotRemoteClient(dispatch, async () => [], () => {})
await expect(client.call('btw', { sessionId: 'bot', text: 'progress?' })).rejects.toThrow('disconnected')
expect(dispatch).toHaveBeenCalledTimes(1)
})
it('opens only current Bot/group sessions from the same official Harness catalog', async () => {
await runScenarios([
{ name: 'current Bot part', id: 'bot', sessions: [session('part-2')], expected: 'part-2' },
{ name: 'group', id: 'room', sessions: [session('room')], expected: 'room' },
{ name: 'group current part (v0.2.7)', id: 'room', state: { ...botState(), rooms: [{ id: 'room', sessionId: 'room-part-2', name: 'Team', members: ['bot', 'other'] }] }, sessions: [session('room-part-2')], expected: 'room-part-2' },
{ name: 'DSH Agent session in Bot team', id: 'agent-s1', state: { ...botState(), agents: [{ id: 'agent-1', sessions: ['agent-s1'] }] }, sessions: [session('agent-s1')], expected: 'agent-s1' },
{ name: 'old part cannot replace current', id: 'bot', sessions: [session('bot'), session('part-1')] },
{ name: 'ACP identity collision', id: 'bot', sessions: [session('part-2', 'cursor')] },
{ name: 'unlisted session', id: 'other', sessions: [session('other')] },
].map(row => ({ name: row.name, run: async () => {
const client = new BotRemoteClient(vi.fn(async () => envelope(row.state ?? botState())), async () => row.sessions, () => {})
if (row.expected) await expect(client.resolveSession(row.id)).resolves.toMatchObject({ session: { sessionId: row.expected } })
else await expect(client.resolveSession(row.id)).rejects.toThrow()
} })))
const team = parseBotState({
bots: [
{ id: 'chief', sessionId: 'chief-part-2', parts: ['chief-part-1'], name: 'Chief', role: 'Lead', main: true, engine: 'claude-code', appliedModel: 'claude-code/default' },
{ id: 'writer', sessionId: 'writer-part-1', name: 'Writer', role: 'Docs' },
],
rooms: [{ id: 'room-1', sessionId: 'room-part-2', ownParts: ['room-part-1'], name: 'Core Team', members: ['chief', 'writer'] }],
mainBotId: 'chief',
defaultModel: 'deepseek/deepseek-reasoner',
closedCards: { 'chief-part-2': { 'call-1': 'replied', 'call-2': 'dismissed' } },
imVia: { 'chief-part-2': { '10': 'Telegram' } },
connectorRequests: { 'chief-part-2': { 'req-1': { id: 'github' } } },
mailRequests: {},
computer: { enabled: true },
computerLive: { asks: {}, holds: {} },
})
expect(team.bots[0]?.engine).toBe('claude-code')
expect(team.bots[0]?.appliedModel).toBe('claude-code/default')
expect(team.defaultModel).toBe('deepseek/deepseek-reasoner')
expect(team.closedCards).toEqual({ 'chief-part-2': { 'call-1': 'replied', 'call-2': 'dismissed' } })
expect(team.imVia).toEqual({ 'chief-part-2': { '10': 'Telegram' } })
expect(team.connectorRequests).toEqual({ 'chief-part-2': { 'req-1': { id: 'github' } } })
trackScopedBotStateSessions(team, 'test-scope-030')
expect(isScopedKnownBotSessionId('chief', 'test-scope-030')).toBe(true)
expect(isScopedKnownBotSessionId('chief-part-1', 'test-scope-030')).toBe(true)
expect(isScopedKnownBotSessionId('chief-part-2', 'test-scope-030')).toBe(true)
expect(isScopedKnownBotSessionId('room-part-1', 'test-scope-030')).toBe(true)
expect(isScopedKnownBotSessionId('dsh-1', 'test-scope-030')).toBe(false)
// DS-Bot 0.3.0 (#663): only user/schedule/user-question-reply inbox items belong in QueueDock; Bot relays are filtered.
expect(inboxQueuedItems({
'next-turn': [
{ id: 'q-user', source: { kind: 'user', rpcId: 'r-user' }, content: [{ type: 'text', text: 'User queued' }] },
{ id: 'q-bot', source: { kind: 'bot', rpcId: 'r-bot' }, content: [{ type: 'text', text: 'Internal bot relay' }] },
{ id: 'q-sched', source: { kind: 'schedule', rpcId: 'r-sched' }, content: [{ type: 'text', text: 'Scheduled' }] },
{ id: 'q-ans', source: { kind: 'user-question-reply', rpcId: 'r-ans' }, content: [{ type: 'text', text: 'Question reply' }] },
],
})).toEqual([
{ id: 'q-user', rpcId: 'r-user', preview: 'User queued' },
{ id: 'q-sched', rpcId: 'r-sched', preview: 'Scheduled' },
{ id: 'q-ans', rpcId: 'r-ans', preview: 'Question reply' },
])
const directMentions = buildBotMentionRows({ state: team, currentBotId: 'chief' })
expect(directMentions.map(item => item.text)).toEqual(['@Writer '])
const roomMentions = buildBotMentionRows({ state: team, currentRoom: team.rooms[0] })
expect(roomMentions.map(item => item.text)).toEqual(['@Chief ', '@Writer ', '@所有人 '])
const refGroups = buildReferenceChatGroups({
state: team,
currentSessionId: 'chief-part-2',
currentBotId: 'chief',
sessions: [
{ ...session('chief-part-2'), title: 'Chief' },
{ ...session('writer-part-1'), title: 'Writer' },
{ ...session('room-part-2'), title: 'Core Team' },
{ ...session('room-part-1'), title: 'Core Team Part 1' },
{ ...session('dsh-1'), title: '架构讨论', updatedAt: 200 },
{ ...session('dsh-sub'), title: 'Subagent', origin: 'subagent', parentSessionId: 'dsh-1', updatedAt: 300 },
],
})
expect(refGroups.bots).toHaveLength(1)
expect(refGroups.bots[0]?.mentionLabel).toBe('与 Writer 的对话')
expect(refGroups.bots[0]?.mentionText).toBe(sessionMentionText('writer-part-1', '与 Writer 的对话'))
expect(refGroups.conversations.map(item => item.sessionId)).toEqual(['dsh-1'])
const inserted = insertReferenceAtSelection('请参考', { start: 3, end: 3 }, refGroups.conversations[0]!.mentionText)
expect(inserted.text).toBe(`请参考 ${refGroups.conversations[0]!.mentionText}`)
expect(canDeleteBot(team, team.bots[1])).toBe(true)
expect(canDeleteBot(team, team.bots[0])).toBe(true)
const soleMainTeam = parseBotState({
bots: [
{ id: 'chief', sessionId: 'chief-part-2', name: 'Chief', main: true },
{ id: 'priv', sessionId: 'priv-part-1', name: 'Private', main: false, private: true },
],
rooms: [],
mainBotId: 'chief',
})
expect(canDeleteBot(soleMainTeam, soleMainTeam.bots[0])).toBe(false)
expect(canDeleteBot(soleMainTeam, soleMainTeam.bots[1])).toBe(true)
})
it('keeps roster previews scoped to current Harness sessions and rejects stale catalog responses', async () => {
await runScenarios(['current', 'other-backend', 'replaced', 'aborted'].map(mode => ({ name: mode, run: async () => {
let current = true
const controller = new NativeAbortController()
const client = new BotRemoteClient(async () => envelope({ ...botState(), exchangeTurns: { 'part-2': [2] } }), async () => {
if (mode === 'replaced') current = false
if (mode === 'aborted') controller.abort()
return [{ ...session('part-2', mode === 'other-backend' ? 'cursor' : 'harness'), projections: { values: { turnOutline: [
{ turn: 1, response: 'Visible reply' }, { turn: 2, response: 'Internal exchange' },
] } } }, { ...session('part-1'), projections: { values: { turnOutline: [{ turn: 3, response: 'Old part' }] } } }]
}, () => { if (!current) throw new Error('replaced') })
const result = client.state(controller.signal as AbortSignal, true)
if (mode === 'replaced' || mode === 'aborted') await expect(result).rejects.toThrow()
else expect((await result).bots[0]?.preview).toBe(mode === 'current' ? 'Visible reply' : '')
} })))
})
it('forwards native Bot answers once and rejects unreviewed operations and broad approval', async () => {
await runScenarios([
{ name: 'aside', endpoint: 'btw', payload: { sessionId: 'bot', text: 'progress?' }, allowed: true },
{ name: 'cancel aside', endpoint: 'btw-cancel', payload: { sessionId: 'bot', id: 'aside' }, allowed: true },
{ name: 'delete aside', endpoint: 'btw-delete', payload: { sessionId: 'bot', cardId: 'aside' }, allowed: true },
{ name: 'continue group', endpoint: 'room-continue', payload: { roomId: 'room' }, allowed: true },
{ name: 'stop room work', endpoint: 'stop-room-work', payload: { roomId: 'room' }, allowed: true },
{ name: 'goal control', endpoint: 'goal-control', payload: { roomId: 'room', action: 'pause' }, allowed: true },
{ name: 'run stats', endpoint: 'run-stats', payload: { botId: 'bot' }, allowed: true },
{ name: 'new part (0.3.0)', endpoint: 'bot-new-part', payload: { botId: 'bot' }, allowed: true },
{ name: 'open earlier part (0.3.0)', endpoint: 'bot-open-part', payload: { botId: 'bot', sessionId: 'part-1' }, allowed: true },
{ name: 'create schedule (0.3.0)', endpoint: 'schedule-create', payload: { title: 'Daily', prompt: 'Brief', target: { botId: 'bot' }, schedule: { kind: 'daily', time: '09:00' } }, allowed: true },
{ name: 'delete schedule (0.3.0)', endpoint: 'schedule-delete', payload: { sessionId: 'part-2', id: 'sched-1' }, allowed: true },
{ name: 'memory view (0.3.0)', endpoint: 'memory-view', payload: { id: 'bot' }, allowed: true },
{ name: 'set prefs (0.3.0)', endpoint: 'set-prefs', payload: { layout: 'bubble' }, allowed: true },
{ name: 'browser takeover (0.3.0)', endpoint: 'browser-takeover', payload: { botId: 'bot' }, allowed: true },
{ name: 'send', endpoint: 'send', payload: { sessionId: 'bot', text: 'hello' }, allowed: true },
{ name: 'card', endpoint: 'view-reply', payload: { sessionId: 'part-2', viewId: 'view', action: 'form', values: { fields: { name: 'value' } } }, allowed: true },
{ name: 'one time', endpoint: 'approval-answer', payload: { id: 'approval', choice: 'allow' }, allowed: true },
{ name: 'reject', endpoint: 'approval-answer', payload: { id: 'approval', choice: 'reject' }, allowed: true },
{ name: 'broad approval', endpoint: 'approval-answer', payload: { choice: 'allow_session' }, allowed: false },
{ name: 'credential write', endpoint: 'secret-set', payload: {}, allowed: false },
{ name: 'local agent registration (0.3.0)', endpoint: 'local-agent-add', payload: {}, allowed: false },
{ name: 'im pairing (0.3.0)', endpoint: 'im-pair', payload: {}, allowed: false },
{ name: 'connector command (0.3.0)', endpoint: 'connector-add', payload: {}, allowed: false },
{ name: 'mail account (0.3.0)', endpoint: 'mail-account-add', payload: {}, allowed: false },
{ name: 'computer control (0.3.0)', endpoint: 'computer-set-enabled', payload: {}, allowed: false },
{ name: 'unknown route operation', endpoint: 'future-operation', payload: {}, allowed: false },
].map(row => ({ name: row.name, run: async () => {
const dispatch = vi.fn(async () => envelope(true))
const client = new BotRemoteClient(dispatch, async () => [], () => {})
if (row.allowed) {
await expect(client.call(row.endpoint as BotOperation, row.payload)).resolves.toBe(true)
expect(dispatch).toHaveBeenCalledTimes(1)
expect(dispatch).toHaveBeenCalledWith({ endpoint: row.endpoint, payload: row.payload }, undefined)
} else { await expect(client.call(row.endpoint as BotOperation, row.payload)).rejects.toThrow(); expect(dispatch).not.toHaveBeenCalled() }
} })))
const dispatch = vi.fn(async () => { throw new Error('timeout') })
const client = new BotRemoteClient(dispatch, async () => [], () => {})
await expect(client.call('send', { sessionId: 'bot', text: 'hello' })).rejects.toThrow('timeout')
expect(dispatch).toHaveBeenCalledTimes(1)
})
it('rejects Host errors, malformed catalogs, cancellation and late responses without publishing', async () => {
await runScenarios([
{ name: 'missing plugin', response: { status: 404, json: null } },
{ name: 'missing carrier', response: { status: 503, json: null } },
{ name: 'upstream refusal', response: { status: 200, json: { ok: false, error: { code: 'bot/stale' } } } },
{ name: 'missing current session', response: envelope({ ...botState(), bots: [{ id: 'bot' }] }) },
{ name: 'duplicate identity', response: envelope({ ...botState(), rooms: [{ id: 'bot', members: [] }] }) },
{ name: 'array envelope', response: [] },
].map(row => ({ name: row.name, run: async () => {
const sessions = vi.fn(async () => [])
const client = new BotRemoteClient(async () => row.response, sessions, () => {})
await expect(client.resolveSession('bot')).rejects.toThrow()
expect(sessions).not.toHaveBeenCalled()
} })))
let current = true
const dispatch = vi.fn(async () => { current = false; return envelope(botState()) })
const client = new BotRemoteClient(dispatch, async () => [], () => { if (!current) throw new Error('replaced') })
await expect(client.state()).rejects.toThrow('replaced')
const aborted = new AbortController(); aborted.abort()
current = true; dispatch.mockClear()
await expect(client.state(aborted.signal)).rejects.toThrow()
expect(dispatch).not.toHaveBeenCalled()
})
})