Import apps/android/src/services/bot-room-rows.ts

This commit is contained in:
QQ 2026-11-14 14:16:54 +08:00
parent b942cd80c4
commit d2d325b1ff
1 changed files with 83 additions and 0 deletions

View File

@ -0,0 +1,83 @@
import type { BotObject } from './bot-catalog'
/**
* The two Host routes that can serve one group round's rows. `group-rows` reads the
* group's book and also answers after the round settled; `room-progress` only knows
* the rounds still running, which is all a Host from before 0.6.4 can answer.
*/
export type RoomRowsEndpoint = 'group-rows' | 'room-progress'
export type RoomRowsCall = (endpoint: RoomRowsEndpoint, payload: BotObject, signal?: AbortSignal) => Promise<unknown>
export interface RoomRowsRequest {
roomId: string
/** The `group_relay` call whose rows this ledger row draws. */
callId: string
range: { from: number; to?: number; anchor?: string }
}
export interface RoomRowsPoll {
/** Rows to render. Absent when this poll learned nothing, so the snapshot stays. */
rows?: BotObject[]
/** A later poll may still add rows. */
open: boolean
/** The Host answered through `room-progress` because `group-rows` is unavailable. */
legacy: boolean
/** The Host answered (an entry was present or not); false means neither route replied. */
answered: boolean
}
/**
* Read one round's rows, preferring the persisted route. Two different Hosts answer
* `group-rows` with an error instead of rows: a Remote Host built before the route was
* allowlisted rejects the call itself (`The plugin route call is invalid for the remote
* channel`), and a DS-Bot older than the route answers `Unknown endpoint group-rows`
* with `ok: false`. Both mean the same thing to this client, so any failure falls back
* to the live round instead of surfacing version-specific text and retrying forever.
*/
export async function pollRoomRows(call: RoomRowsCall, request: RoomRowsRequest, signal?: AbortSignal): Promise<RoomRowsPoll> {
try {
const value = await call('group-rows', { roomId: request.roomId, ...request.range }, signal)
if (!isObject(value)) throw new Error('group-rows returned an unexpected payload')
// `open` covers "a later anchor may end these rows"; `active` (DS-Bot 0.3.2+) says
// whether the group is working right now. Without `active` a settled newest round
// keeps `open` true until the user's next message, which polled once a second forever.
const open = value.open === true && value.active !== false
return { rows: objects(value.rows), open, legacy: false, answered: true }
} catch (error) {
if (signal?.aborted) throw error
}
try {
const progress = objects(await call('room-progress', { roomId: request.roomId }, signal))
const entry = progress.find(item => item.callId === request.callId)
return entry === undefined
? { open: true, legacy: true, answered: true }
: { rows: objects(entry.replies), open: true, legacy: true, answered: true }
} catch (error) {
if (signal?.aborted) throw error
// Neither route answered; keep the snapshot and let the next poll try again.
return { open: true, legacy: true, answered: false }
}
}
/** How long each route waits before asking again. */
export const ROOM_ROWS_INTERVAL_MS = 1000
export const ROOM_ROWS_LEGACY_INTERVAL_MS = 2000
/** Consecutive empty legacy polls before a settled round stops being polled. */
export const ROOM_ROWS_LEGACY_MISSES = 2
/**
* Which rows a ledger line draws. The live snapshot wins only while it holds replies:
* a list captured just as the round opened is empty and knows nothing the rows fetched
* for the settled round do not, so letting it win hid the members' replies.
*/
export function preferredRoomRows(live: BotObject[] | undefined, fetched: BotObject[]): BotObject[] {
return live !== undefined && live.length > 0 ? live : fetched
}
function isObject(value: unknown): value is BotObject {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}
function objects(value: unknown): BotObject[] {
return Array.isArray(value) ? value.filter(isObject) : []
}