diff --git a/apps/android/src/state/bot-store.ts b/apps/android/src/state/bot-store.ts new file mode 100644 index 0000000..661df90 --- /dev/null +++ b/apps/android/src/state/bot-store.ts @@ -0,0 +1,490 @@ +import { create } from 'zustand' +import { strings as s } from '../locales/i18n' +import { browseScope } from '../services/browse-memory' +import { + botSessionOwnerKey, + isScopedKnownBotSessionId, + markScopedBotSessionId, + object, + resolveBotTargetSessionId, + text, + trackScopedBotStateSessions, + type BotObject, + type BotOperation, + type BotRemoteClient, + type BotState, +} from '../services/bot-catalog' +import type { RemoteSession } from '../types' +import { getConnectionGeneration, requireBotClient, useAppStore } from './store' + +export interface BotContextMenuTarget { + kind: 'bot' | 'room' | 'agent' + id: string +} + +export interface BotEditorTarget { + kind: 'bot' | 'room' + id?: string +} + +export interface BotReportTarget { + title: string + kind: 'usage' | 'schedules' + value: unknown +} + +export function currentBotScope(): string { + return browseScope(useAppStore.getState()) +} + +export function markBotSessionId(sessionId: string | undefined, scope = currentBotScope()): void { + markScopedBotSessionId(sessionId, scope) +} + +export function trackBotStateSessions(state: BotState | undefined, scope = currentBotScope()): void { + trackScopedBotStateSessions(state, scope) +} + +export function isKnownBotSessionId( + sessionId: string | undefined, + state?: BotState, + scope = currentBotScope(), +): boolean { + return isScopedKnownBotSessionId(sessionId, scope, state) +} + +interface BotTeamStoreState { + scope: string + state?: BotState + session?: RemoteSession + openedSessionKey?: string + openError?: string + openAttempt: number + loading: boolean + busy: boolean + error?: string + actionError?: string + selectedId?: string + editor?: BotEditorTarget + detailsOpen: boolean + report?: BotReportTarget + contextMenu?: BotContextMenuTarget + runStats?: BotObject | null + ensureScope: (scope: string) => void + setSelectedId: (id?: string) => void + setEditor: (editor?: BotEditorTarget) => void + setDetailsOpen: (open: boolean) => void + setReport: (report?: BotReportTarget) => void + setContextMenu: (target?: BotContextMenuTarget) => void + clearErrors: () => void + refresh: (force?: boolean, signal?: AbortSignal) => Promise + syncSelectedSession: (options?: { selectedId?: string; force?: boolean; signal?: AbortSignal }) => Promise + retryOpenSession: () => Promise + perform: (operation: BotOperation, payload?: BotObject, signal?: AbortSignal) => Promise<{ ok: boolean; value?: unknown }> + loadRunStats: (botId: string, signal?: AbortSignal) => Promise +} + +let activeRevision = 0 +let activeOpenRevision = 0 +let activeOpenAbort: AbortController | undefined +let activeOpenKey: string | undefined +let activeOpenPromise: Promise | undefined +let actionLocked = false +let sessionSyncActive = false +let lastObservedScope = '' +let lastObservedGen = -1 +let lastObservedDeviceId = '' +let lastObservedConnected = false +let connectionEpoch = 0 + +function resetOpenTracking(): void { + ++activeOpenRevision + activeOpenAbort?.abort() + activeOpenAbort = undefined + activeOpenKey = undefined + activeOpenPromise = undefined +} + +function observeAppConnection(): { scope: string; connected: boolean; epoch: number } { + const appState = useAppStore.getState() + const scope = browseScope(appState) + const connected = appState.connection.phase === 'connected' + const gen = getConnectionGeneration() + const deviceId = appState.selectedDevice?.deviceId ?? '' + if (!connected) { + lastObservedConnected = false + return { scope, connected: false, epoch: connectionEpoch } + } + if ( + !lastObservedConnected + || scope !== lastObservedScope + || gen !== lastObservedGen + || deviceId !== lastObservedDeviceId + ) { + ++connectionEpoch + lastObservedConnected = true + lastObservedScope = scope + lastObservedGen = gen + lastObservedDeviceId = deviceId + } + return { scope, connected: true, epoch: connectionEpoch } +} + +function getClient(): { value?: BotRemoteClient; error?: string } { + try { + return { value: requireBotClient() } + } catch (error) { + return { error: error instanceof Error ? error.message : s.bots.unavailable } + } +} + +export const useBotTeamStore = create((set, get) => ({ + scope: '', + state: undefined, + session: undefined, + openedSessionKey: undefined, + openError: undefined, + openAttempt: 0, + loading: false, + busy: false, + error: undefined, + actionError: undefined, + selectedId: undefined, + editor: undefined, + detailsOpen: false, + report: undefined, + contextMenu: undefined, + runStats: undefined, + + ensureScope: (nextScope: string) => { + if (get().scope === nextScope) return + ++activeRevision + resetOpenTracking() + actionLocked = false + sessionSyncActive = false + set({ + scope: nextScope, + state: undefined, + session: undefined, + openedSessionKey: undefined, + openError: undefined, + openAttempt: 0, + loading: false, + busy: false, + error: undefined, + actionError: undefined, + selectedId: undefined, + editor: undefined, + detailsOpen: false, + report: undefined, + contextMenu: undefined, + runStats: undefined, + }) + }, + + setSelectedId: (id?: string) => { + if (id === undefined) { + resetOpenTracking() + sessionSyncActive = false + set({ + selectedId: undefined, + session: undefined, + openedSessionKey: undefined, + openError: undefined, + actionError: undefined, + detailsOpen: false, + runStats: undefined, + }) + return + } + set({ selectedId: id, actionError: undefined, detailsOpen: false, runStats: undefined }) + if (sessionSyncActive && get().state !== undefined) { + void get().syncSelectedSession({ selectedId: id }) + } + }, + + setEditor: (editor?: BotEditorTarget) => set({ editor, actionError: undefined }), + setDetailsOpen: (detailsOpen: boolean) => set({ detailsOpen }), + setReport: (report?: BotReportTarget) => set({ report }), + setContextMenu: (contextMenu?: BotContextMenuTarget) => set({ contextMenu }), + clearErrors: () => set({ error: undefined, actionError: undefined, openError: undefined }), + + refresh: async (force = false, signal?: AbortSignal) => { + const scope = currentBotScope() + get().ensureScope(scope) + if (actionLocked && !force) { + set({ loading: false }) + return + } + const client = getClient() + if (!client.value) { + set({ loading: false, error: client.error }) + return + } + const rev = ++activeRevision + if (get().state === undefined) set({ loading: true }) + try { + const next = await client.value.state(signal, true) + if (rev !== activeRevision || get().scope !== scope) return + trackBotStateSessions(next, scope) + const prevState = get().state + const currentSelected = get().selectedId + const validIds = new Set([ + ...next.bots.map(b => b.id), + ...next.rooms.map(r => r.id), + ...next.agents.flatMap(a => a.sessions), + ]) + const defaultSelected = next.mainBotId + ?? next.bots.find(b => b.tile)?.id + ?? next.bots.find(b => b.main)?.id + ?? next.bots[0]?.id + ?? next.rooms[0]?.id + const resolvedSelected = currentSelected !== undefined + ? (validIds.has(currentSelected) ? currentSelected : defaultSelected) + : (prevState === undefined ? defaultSelected : undefined) + set({ + state: next, + error: undefined, + loading: false, + selectedId: resolvedSelected, + }) + if (sessionSyncActive && resolvedSelected !== undefined) { + await get().syncSelectedSession({ selectedId: resolvedSelected, signal }) + } + } catch (reason) { + if (rev !== activeRevision || get().scope !== scope) return + set({ + loading: false, + error: reason instanceof Error ? reason.message : s.bots.unavailable, + }) + } + }, + + syncSelectedSession: async (options = {}) => { + sessionSyncActive = true + const { scope, connected, epoch } = observeAppConnection() + get().ensureScope(scope) + const state = get().state + const selectedId = options.selectedId !== undefined ? options.selectedId : get().selectedId + const targetSessionId = resolveBotTargetSessionId(state, selectedId) + if (!selectedId || !targetSessionId) { + resetOpenTracking() + if (get().session !== undefined || get().openedSessionKey !== undefined || get().openError !== undefined) { + set({ session: undefined, openedSessionKey: undefined, openError: undefined }) + } + return undefined + } + if (!connected) { + return get().session + } + const client = getClient() + if (!client.value) { + set({ session: undefined, openedSessionKey: undefined, openError: client.error }) + return undefined + } + const sessionKey = botSessionOwnerKey(scope, epoch, selectedId, targetSessionId)! + const currentSession = get().session + const appSelectedSession = useAppStore.getState().selectedSession + if ( + !options.force + && get().openedSessionKey === sessionKey + && currentSession?.sessionId === targetSessionId + && appSelectedSession?.sessionId === targetSessionId + ) { + return currentSession + } + if (!options.force && activeOpenKey === sessionKey && activeOpenPromise !== undefined) { + return activeOpenPromise + } + activeOpenAbort?.abort() + const control = new AbortController() + activeOpenAbort = control + activeOpenKey = sessionKey + const onExternalAbort = () => control.abort() + options.signal?.addEventListener('abort', onExternalAbort, { once: true }) + const openRev = ++activeOpenRevision + if (get().openedSessionKey !== sessionKey) { + set({ session: undefined, openError: undefined }) + } else { + set({ openError: undefined }) + } + const task = (async (): Promise => { + try { + const resolved = await client.value!.resolveSession(selectedId, control.signal) + trackBotStateSessions(resolved.state, scope) + markBotSessionId(resolved.session.sessionId, scope) + if (control.signal.aborted || openRev !== activeOpenRevision || get().scope !== scope) { + return undefined + } + const latestSelected = options.selectedId !== undefined ? options.selectedId : get().selectedId + if (latestSelected !== selectedId) return undefined + const resolvedKey = botSessionOwnerKey(scope, epoch, selectedId, resolved.session.sessionId)! + const opened = await useAppStore.getState().openSession(resolved.session) + if (control.signal.aborted || openRev !== activeOpenRevision || get().scope !== scope) { + return undefined + } + if (opened) { + set(current => ({ + ...(current.state !== undefined && resolveBotTargetSessionId(current.state, selectedId) !== resolved.session.sessionId + ? { state: resolved.state } + : {}), + session: resolved.session, + openedSessionKey: resolvedKey, + openError: undefined, + })) + return resolved.session + } + set({ + session: undefined, + openedSessionKey: undefined, + openError: useAppStore.getState().error ?? s.bots.sessionUnavailable, + }) + return undefined + } catch (reason) { + if (control.signal.aborted || openRev !== activeOpenRevision || get().scope !== scope) { + return undefined + } + set({ + session: undefined, + openedSessionKey: undefined, + openError: reason instanceof Error ? reason.message : s.bots.unavailable, + }) + return undefined + } finally { + options.signal?.removeEventListener('abort', onExternalAbort) + if (activeOpenAbort === control) { + activeOpenAbort = undefined + activeOpenKey = undefined + activeOpenPromise = undefined + } + } + })() + activeOpenPromise = task + return task + }, + + retryOpenSession: async () => { + set(state => ({ + error: undefined, + actionError: undefined, + openError: undefined, + openedSessionKey: undefined, + openAttempt: state.openAttempt + 1, + })) + await get().refresh(true) + await get().syncSelectedSession({ force: true }) + }, + + perform: async (operation: BotOperation, payload?: BotObject, signal?: AbortSignal) => { + const scope = currentBotScope() + get().ensureScope(scope) + const client = getClient() + if (!client.value || actionLocked) return { ok: false } + actionLocked = true + ++activeRevision + set({ busy: true, actionError: undefined }) + let result: { ok: boolean; value?: unknown } = { ok: false } + try { + if (operation === 'delete-bot') { + const targetId = text(payload?.id) + const currentState = get().state + const targetBot = currentState?.bots.find(entry => entry.id === targetId) + if (targetBot?.main && currentState) { + const mainBots = currentState.bots.filter(entry => entry.main) + if (mainBots.length > 1) { + await client.value.call('set-main', { id: targetId, main: false }, signal) + } else { + const replacement = currentState.bots.find(entry => entry.id !== targetId && !entry.private) + if (replacement) { + await client.value.call( + 'set-main', + { id: replacement.id, main: true, primary: true, replace: targetId }, + signal, + ) + } + } + } + } + const value = await client.value.call(operation, payload ?? null, signal) + if (get().scope !== scope) return { ok: false } + result = { ok: true, value } + if (operation === 'create-bot' || operation === 'duplicate-bot' || operation === 'create-room') { + const id = text(object(value).id) + if (id) set({ selectedId: id, detailsOpen: false }) + } + if (operation === 'agent-session') { + const sessionId = text(object(value).sessionId) + if (sessionId) set({ selectedId: sessionId, detailsOpen: false }) + } + if (operation === 'bot-new-part' || operation === 'bot-open-part') { + set({ detailsOpen: false }) + } + if (operation === 'delete-bot' || operation === 'delete-room') { + const deletedId = text(payload?.id) + if (!deletedId || get().selectedId === deletedId) { + resetOpenTracking() + sessionSyncActive = false + set({ + selectedId: undefined, + session: undefined, + openedSessionKey: undefined, + openError: undefined, + detailsOpen: false, + editor: undefined, + contextMenu: undefined, + runStats: undefined, + }) + } else { + set({ + detailsOpen: false, + editor: undefined, + contextMenu: undefined, + }) + } + } + if (operation === 'usage' || operation === 'schedules') { + set({ + report: { + title: operation === 'usage' ? s.bots.usage : s.bots.schedules, + kind: operation, + value, + }, + }) + } + } catch (reason) { + if (get().scope === scope) { + set({ actionError: reason instanceof Error ? reason.message : s.bots.unknownOutcome }) + } + } finally { + actionLocked = false + if (get().scope === scope) { + await get().refresh(true, signal) + if (get().scope === scope) set({ busy: false }) + } + } + return result + }, + + loadRunStats: async (botId: string, signal?: AbortSignal) => { + const client = getClient() + if (!client.value) return + try { + const value = await client.value.call('run-stats', { botId }, signal) + if (!signal?.aborted) { + set({ runStats: object(value) }) + } + } catch { + // Older DS-Bot hosts may not expose run-stats; ignore silently. + } + }, +})) + +useAppStore.subscribe(appState => { + if (appState.connection.phase !== 'connected') { + lastObservedConnected = false + if (useBotTeamStore.getState().openedSessionKey !== undefined) { + resetOpenTracking() + useBotTeamStore.setState({ openedSessionKey: undefined }) + } + } +})