From 2346009a6aab31529594a14aa8e79ae1ca8c82cc Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:23:07 +0800 Subject: [PATCH] Import apps/android/tests/bot-catalog.test.ts --- apps/android/tests/bot-catalog.test.ts | 265 +++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 apps/android/tests/bot-catalog.test.ts diff --git a/apps/android/tests/bot-catalog.test.ts b/apps/android/tests/bot-catalog.test.ts new file mode 100644 index 0000000..830fa61 --- /dev/null +++ b/apps/android/tests/bot-catalog.test.ts @@ -0,0 +1,265 @@ +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() + }) +})