Import apps/android/src/state/bot-store.ts

This commit is contained in:
QQ 2026-11-14 14:19:11 +08:00
parent 0a3fd94610
commit b349dcb905
1 changed files with 490 additions and 0 deletions

View File

@ -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<void>
syncSelectedSession: (options?: { selectedId?: string; force?: boolean; signal?: AbortSignal }) => Promise<RemoteSession | undefined>
retryOpenSession: () => Promise<void>
perform: (operation: BotOperation, payload?: BotObject, signal?: AbortSignal) => Promise<{ ok: boolean; value?: unknown }>
loadRunStats: (botId: string, signal?: AbortSignal) => Promise<void>
}
let activeRevision = 0
let activeOpenRevision = 0
let activeOpenAbort: AbortController | undefined
let activeOpenKey: string | undefined
let activeOpenPromise: Promise<RemoteSession | undefined> | 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<BotTeamStoreState>((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<RemoteSession | undefined> => {
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 })
}
}
})