ds-harness-remote-fast/apps/android/src/services/bot-catalog.ts

424 lines
18 KiB
TypeScript

import type { RemoteSession } from '../types'
import { strings } from '../locales/i18n'
export type BotObject = Record<string, unknown>
export interface BotEntry {
id: string
sessionId: string
parts?: string[]
name: string
role: string
instructions: string
model: string
appliedModel?: string
effort: string
engine?: string
workDir?: string
permission?: string
private?: boolean
browserGrants?: BotObject[]
capabilities?: string[]
color?: string
avatar?: { shape?: string; image?: string }
preview?: string
main: boolean
tile?: boolean
pinned?: boolean
hidden?: boolean
waiting?: boolean
createdAt?: number
}
export interface BotRoom {
preview?: string
id: string
sessionId: string
ownParts?: string[]
parts?: string[]
name: string
members: string[]
notice: string
admin: string
mode?: string
workDir?: string
permission?: string
paused?: boolean
pinned?: boolean
hidden?: boolean
goal?: BotObject
createdAt?: number
}
export interface BotAgent {
id: string
sessions: string[]
pinned?: boolean
createdAt?: number
}
export interface BotState {
workspaceId?: string
mainBotId?: string
mainBotIds?: string[]
bots: BotEntry[]
rooms: BotRoom[]
agents: BotAgent[]
exchangeTurns: BotObject
btwCards: BotObject
btwSupported: boolean
sideChats: BotObject
activity: BotObject
work: {
bots: BotObject
rooms: BotObject
waiting: BotObject
turns: BotObject
steered: BotObject
}
questions: BotObject
views: BotObject
closedCards: BotObject
imVia: BotObject
connectorRequests: BotObject
mailRequests: BotObject
computer?: BotObject
computerLive?: BotObject
prefs?: BotObject
browser?: boolean
memory?: boolean
permissions?: BotObject
secrets?: BotObject[]
capabilities?: BotObject[]
capabilityStatuses?: BotObject
connectors?: BotObject
im?: BotObject
imStatus?: BotObject
privateArchives?: BotObject[]
colors?: string[]
approvals: BotObject[]
models: BotObject[]
defaultModel?: string
readOnly?: string
}
// Android only exposes the reviewed Bot workflows, never arbitrary plugin routes.
export const BOT_OPERATIONS = [
'state', 'models', 'efforts', 'providers', 'local-agents',
'exchange', 'exchange-text', 'file-text', 'earlier', 'chat', 'run-stats', 'thinking', 'usage', 'room-progress', 'group-rows',
'schedules', 'schedule-create', 'schedule-delete',
'memory-view', 'memory-history', 'memory-ask', 'memory-forget', 'memory-restore',
'folders', 'folder-list', 'team-workspace', 'set-prefs',
'browser-takeover', 'browser-give-back', 'browser-stop',
'create-bot', 'duplicate-bot', 'update-bot', 'delete-bot', 'set-main', 'set-flags', 'resume', 'bot-new-part', 'bot-open-part',
'create-room', 'update-room', 'delete-room', 'stop-room-work', 'goal-draft', 'goal-control',
'add-agent', 'agent-session', 'agent-adopt', 'agent-archive', 'agent-rename', 'remove-agent',
'send', 'btw', 'btw-cancel', 'btw-delete', 'side-new', 'side-ask', 'side-cancel', 'side-close',
'room-continue', 'answer-question', 'dismiss-question', 'dismiss-view', 'view-reply', 'approval-answer', 'stop-member-work',
] as const
export type BotOperation = typeof BOT_OPERATIONS[number]
export class BotRemoteClient {
constructor(
private readonly dispatch: (body: { endpoint: BotOperation; payload: BotObject | null }, signal?: AbortSignal) => Promise<unknown>,
private readonly readSessions: () => Promise<RemoteSession[]>,
private readonly assertCurrent: () => void,
) {}
async call(endpoint: BotOperation, payload: BotObject | null = null, signal?: AbortSignal): Promise<unknown> {
this.assertCurrent()
checkAborted(signal)
if (!(BOT_OPERATIONS as readonly string[]).includes(endpoint)
|| (payload !== null && !isBotObject(payload))
|| (endpoint === 'approval-answer' && payload?.choice !== 'allow' && payload?.choice !== 'reject')) {
throw new Error(strings.bots.operationDenied)
}
const response = await this.dispatch({ endpoint, payload }, signal)
this.assertCurrent()
checkAborted(signal)
if (!isBotObject(response)) throw new Error(strings.bots.invalid)
if (response.status === 404) throw new Error(strings.bots.notInstalled)
if (response.status === 503) throw new Error(strings.bots.unsupported)
if (response.status !== 200 || !isBotObject(response.json)) throw new Error(strings.bots.unavailable)
const envelope = response.json
if (envelope.ok !== true) {
const error = object(envelope.error)
if (error.code === 'bot/stale') throw new Error(strings.bots.stale)
throw new Error(typeof error.message === 'string' ? error.message : strings.bots.unavailable)
}
return envelope.value
}
async state(signal?: AbortSignal, withPreviews = false): Promise<BotState> {
const state = parseBotState(await this.call('state', null, signal))
if (!withPreviews) return state
const sessions = await this.readSessions()
this.assertCurrent()
checkAborted(signal)
const catalog = new Map(sessions.filter(entry => (entry.backend ?? 'harness') === 'harness').map(entry => [entry.sessionId, entry]))
for (const bot of state.bots) bot.preview = sessionPreview(catalog.get(bot.sessionId), state.exchangeTurns[bot.sessionId])
for (const room of state.rooms) room.preview ||= sessionPreview(catalog.get(room.sessionId || room.id))
return state
}
/** Resolve only a current Bot/group returned by this Host, against its official catalog. */
async resolveSession(id: string, signal?: AbortSignal): Promise<{ state: BotState; session: RemoteSession }> {
const state = await this.state(signal)
const bot = state.bots.find(entry => entry.id === id)
const room = state.rooms.find(entry => entry.id === id)
const agentSession = state.agents.flatMap(entry => entry.sessions).find(sessionId => sessionId === id)
const sessionId = bot?.sessionId ?? (room ? (room.sessionId || room.id) : agentSession)
if (sessionId === undefined) throw new Error(strings.bots.sessionUnavailable)
const sessions = await this.readSessions()
this.assertCurrent()
checkAborted(signal)
const session = sessions.find(item => item.sessionId === sessionId && (item.backend ?? 'harness') === 'harness')
if (session === undefined) throw new Error(strings.bots.sessionUnavailable)
return { state, session }
}
}
export function parseBotState(value: unknown): BotState {
if (!isBotObject(value) || !Array.isArray(value.bots) || !Array.isArray(value.rooms)) throw new Error(strings.bots.invalid)
const hasExplicitMainIds = Array.isArray(value.mainBotIds) || nonempty(value.mainBotId)
const mainBotIds = Array.isArray(value.mainBotIds)
? value.mainBotIds.filter(nonempty)
: nonempty(value.mainBotId)
? [value.mainBotId]
: []
const mainBotId = nonempty(value.mainBotId) ? value.mainBotId : mainBotIds[0]
const bots = value.bots.map(entry => {
if (!isBotObject(entry) || !nonempty(entry.id) || !nonempty(entry.sessionId)) throw new Error(strings.bots.invalid)
const avatarObj = object(entry.avatar)
return {
id: entry.id,
sessionId: entry.sessionId,
...(Array.isArray(entry.parts) ? { parts: entry.parts.filter(nonempty) } : {}),
name: text(entry.name) || entry.id,
color: text(entry.color),
avatar: { shape: text(avatarObj.shape), ...(nonempty(avatarObj.image) ? { image: avatarObj.image } : {}) },
role: text(entry.role),
instructions: text(entry.instructions),
model: text(entry.model),
...(nonempty(entry.appliedModel) ? { appliedModel: entry.appliedModel } : {}),
effort: text(entry.effort),
...(nonempty(entry.engine) ? { engine: entry.engine } : {}),
...(nonempty(entry.workDir) ? { workDir: entry.workDir } : {}),
...(nonempty(entry.permission) ? { permission: entry.permission } : {}),
...(entry.private === true ? { private: true } : {}),
...(Array.isArray(entry.browserGrants) ? { browserGrants: objects(entry.browserGrants) } : {}),
...(Array.isArray(entry.capabilities) ? { capabilities: entry.capabilities.filter(nonempty) } : {}),
main: hasExplicitMainIds ? mainBotIds.includes(entry.id) : entry.main === true,
tile: mainBotId === entry.id,
...(entry.pinned === true ? { pinned: true } : {}),
...(entry.hidden === true ? { hidden: true } : {}),
...(entry.waiting === true ? { waiting: true } : {}),
...(typeof entry.createdAt === 'number' ? { createdAt: entry.createdAt } : {}),
}
})
const rooms = value.rooms.map(entry => {
if (!isBotObject(entry) || !nonempty(entry.id) || !Array.isArray(entry.members) || !entry.members.every(nonempty)) throw new Error(strings.bots.invalid)
const sessionId = text(entry.sessionId) || entry.id
return {
preview: compactPreview(text(entry.preview)),
id: entry.id,
sessionId,
...(Array.isArray(entry.ownParts) ? { ownParts: entry.ownParts.filter(nonempty) } : {}),
...(Array.isArray(entry.parts) ? { parts: entry.parts.filter(nonempty) } : {}),
name: text(entry.name) || entry.id,
members: entry.members as string[],
notice: text(entry.notice),
admin: text(entry.admin),
...(nonempty(entry.mode) ? { mode: entry.mode } : {}),
...(nonempty(entry.workDir) ? { workDir: entry.workDir } : {}),
...(nonempty(entry.permission) ? { permission: entry.permission } : {}),
paused: objects(entry.paused).length > 0 || entry.paused === true,
...(entry.pinned === true ? { pinned: true } : {}),
...(entry.hidden === true ? { hidden: true } : {}),
...(isBotObject(entry.goal) ? { goal: entry.goal } : {}),
...(typeof entry.createdAt === 'number' ? { createdAt: entry.createdAt } : {}),
}
})
const agents = Array.isArray(value.agents)
? value.agents.filter(isBotObject).filter(entry => nonempty(entry.id)).map(entry => ({
id: entry.id as string,
sessions: Array.isArray(entry.sessions) ? entry.sessions.filter(nonempty) : [],
...(entry.pinned === true ? { pinned: true } : {}),
...(typeof entry.createdAt === 'number' ? { createdAt: entry.createdAt } : {}),
}))
: []
const ids = [...bots, ...rooms].map(entry => entry.id)
if (new Set(ids).size !== ids.length) throw new Error(strings.bots.invalid)
const workObj = object(value.work)
return {
...(nonempty(value.workspaceId) ? { workspaceId: value.workspaceId } : {}),
...(mainBotId !== undefined ? { mainBotId } : {}),
...(mainBotIds.length > 0 ? { mainBotIds } : {}),
bots,
rooms,
agents,
btwCards: object(value.btwCards),
btwSupported: isBotObject(value.btwCards),
sideChats: object(value.sideChats),
exchangeTurns: object(value.exchangeTurns),
activity: object(value.activity),
work: {
bots: object(workObj.bots),
rooms: object(workObj.rooms),
waiting: object(workObj.waiting),
turns: object(workObj.turns),
steered: object(workObj.steered),
},
questions: object(value.questions),
views: object(value.views),
closedCards: object(value.closedCards),
imVia: object(value.imVia),
connectorRequests: object(value.connectorRequests),
mailRequests: object(value.mailRequests),
...(isBotObject(value.computer) ? { computer: value.computer } : {}),
...(isBotObject(value.computerLive) ? { computerLive: value.computerLive } : {}),
...(isBotObject(value.prefs) ? { prefs: value.prefs } : {}),
...(typeof value.browser === 'boolean' ? { browser: value.browser } : {}),
...(typeof value.memory === 'boolean' ? { memory: value.memory } : {}),
...(isBotObject(value.permissions) ? { permissions: value.permissions } : {}),
...(Array.isArray(value.secrets) ? { secrets: objects(value.secrets) } : {}),
...(Array.isArray(value.capabilities) ? { capabilities: objects(value.capabilities) } : {}),
...(isBotObject(value.capabilityStatuses) ? { capabilityStatuses: value.capabilityStatuses } : {}),
...(isBotObject(value.connectors) ? { connectors: value.connectors } : {}),
...(isBotObject(value.im) ? { im: value.im } : {}),
...(isBotObject(value.imStatus) ? { imStatus: value.imStatus } : {}),
...(Array.isArray(value.privateArchives) ? { privateArchives: objects(value.privateArchives) } : {}),
...(Array.isArray(value.colors) ? { colors: value.colors.filter(nonempty) } : {}),
approvals: objects(workObj.approvals),
models: objects(value.models),
...(nonempty(value.defaultModel) ? { defaultModel: value.defaultModel } : {}),
...(typeof value.readOnly === 'string' ? { readOnly: value.readOnly } : {}),
}
}
export function isBotObject(value: unknown): value is BotObject { return value !== null && typeof value === 'object' && !Array.isArray(value) }
export function object(value: unknown): BotObject { return isBotObject(value) ? value : {} }
export function objects(value: unknown): BotObject[] { return Array.isArray(value) ? value.filter(isBotObject) : [] }
export function text(value: unknown): string { return typeof value === 'string' ? value : '' }
function nonempty(value: unknown): value is string { return typeof value === 'string' && value.length > 0 }
// React Native's abort-controller implements aborted/events, not throwIfAborted.
function checkAborted(signal?: AbortSignal): void {
if (signal?.aborted) throw signal.reason ?? Object.assign(new Error('The operation was aborted.'), { name: 'AbortError' })
}
// Match the native Bot sidebar: latest visible response, then prompt; never internal exchanges.
function sessionPreview(session?: RemoteSession, hiddenTurns: unknown = []): string {
const hidden = Array.isArray(hiddenTurns) ? hiddenTurns : []
const outline = objects(session?.projections?.values?.turnOutline)
for (let i = outline.length - 1; i >= 0; i--) {
const turn = outline[i]!
if (hidden.includes(turn.turn)) continue
const value = text(turn.response) || text(turn.prompt)
if (value) return compactPreview(value.replace(/^\[(Message from|Reply from|Group chat|Group post from|Bot team setup|Handoff · part|Secret card)(?:[^\r\n]*\]\r?\n|[^\]\r\n]*\])/, ''))
}
return ''
}
function compactPreview(value: string): string { return value.replace(/\s+/g, ' ').trim().slice(0, 240) }
/** Claim /btw before normal sending; refusals never become queued prompts. */
export function botMessageRequest(state: BotState, targetId: string, draft: string): { endpoint: BotOperation; payload: BotObject } {
const message = draft.trim()
const bot = state.bots.find(entry => entry.id === targetId || entry.sessionId === targetId)
const room = state.rooms.find(entry => entry.id === targetId || entry.sessionId === targetId)
const isAgentSession = (state.agents ?? []).some(entry => entry.sessions.includes(targetId))
if ((!bot && !room && !isAgentSession) || state.readOnly !== undefined || !message) throw new Error(strings.bots.sessionUnavailable)
const aside = /^\/btw(?:\s|$)/.test(message)
if (aside) {
if (!bot) throw new Error(strings.bots.btwPrivate)
if (!state.btwSupported) throw new Error(strings.bots.btwUnsupported)
const question = message.slice(4).trim()
if (!question) throw new Error(strings.bots.btwEmpty)
return { endpoint: 'btw', payload: { sessionId: bot.id, text: question } }
}
const resolvedTargetId = bot?.id ?? room?.id ?? targetId
return { endpoint: 'send', payload: { sessionId: resolvedTargetId, text: message } }
}
/**
* Whether a Bot can be deleted: non-main Bots can always be deleted; a Main Bot
* can be deleted when another Main Bot exists or another non-private Bot can
* take over the Main Bot role first.
*/
export function canDeleteBot(state: BotState | undefined, bot: BotEntry | undefined): boolean {
if (!state || !bot || state.readOnly !== undefined) return false
if (!bot.main) return true
const mainCount = state.bots.filter(entry => entry.main).length
if (mainCount > 1) return true
return state.bots.some(entry => entry.id !== bot.id && !entry.private)
}
const knownBotSessionIdsByScope = new Map<string, Set<string>>()
function scopeSet(scope: string): Set<string> {
let set = knownBotSessionIdsByScope.get(scope)
if (!set) {
set = new Set<string>()
knownBotSessionIdsByScope.set(scope, set)
}
return set
}
export function markScopedBotSessionId(sessionId: string | undefined, scope: string): void {
if (!sessionId || !scope) return
scopeSet(scope).add(sessionId)
}
export function trackScopedBotStateSessions(state: BotState | undefined, scope: string): void {
if (!state || !scope) return
const target = scopeSet(scope)
for (const bot of state.bots) {
if (bot.id) target.add(bot.id)
if (bot.sessionId) target.add(bot.sessionId)
if (bot.parts) {
for (const part of bot.parts) {
if (part) target.add(part)
}
}
}
for (const room of state.rooms) {
const primarySessionId = room.sessionId || room.id
if (primarySessionId) target.add(primarySessionId)
if (room.ownParts) {
for (const part of room.ownParts) {
if (part) target.add(part)
}
}
}
}
export function isScopedKnownBotSessionId(
sessionId: string | undefined,
scope: string,
state?: BotState,
): boolean {
if (!sessionId || !scope) return false
if (state) {
trackScopedBotStateSessions(state, scope)
}
return knownBotSessionIdsByScope.get(scope)?.has(sessionId) ?? false
}
export function resolveBotTargetSessionId(
state: BotState | undefined,
selectedId: string | undefined,
): string | undefined {
if (!state || !selectedId) return undefined
const bot = state.bots.find(entry => entry.id === selectedId)
if (bot) return bot.sessionId
const room = state.rooms.find(entry => entry.id === selectedId)
if (room) return room.sessionId || room.id
const isAgentSession = state.agents.some(agent => agent.sessions.includes(selectedId))
return isAgentSession ? selectedId : undefined
}
export function botSessionOwnerKey(
scope: string,
connectionEpoch: number,
selectedId: string | undefined,
targetSessionId: string | undefined,
): string | undefined {
if (!scope || !selectedId || !targetSessionId) return undefined
return `${scope}|epoch:${connectionEpoch}|${selectedId}|${targetSessionId}`
}