@jsbot-tellus/core 2.3.0 → 2.5.0

package/src/core/kernel.ts

@@ -1,6 +1,7 @@
+import type { SnowLumaEvent } from '@snowluma/sdk'
 import type { BotClient } from './client.js'
 import type { AppConfig } from './config/schema.js'
-import { createBotApi } from './api.js'
+import { createBotApi, type BotApi } from './api.js'
 import { Router } from './dispatch/router.js'
 import { PerKeyTaskQueue } from './dispatch/task-queue.js'
 import { Lifecycle, type LifecycleState } from './lifecycle/lifecycle.js'
@@ -28,10 +29,13 @@ export interface KernelOptions {
     plugins?: AnyPluginDefinition[] | undefined
     installer?: PluginInstaller | undefined
     onRestart?: (() => void) | undefined
+    onEvent?: ((event: SnowLumaEvent) => void) | undefined
     drainTimeoutMs?: number | undefined
 }
 
 export class Kernel {
+    readonly api: BotApi
+
     private readonly config: AppConfig
     private readonly client: BotClient
     private readonly logger: Logger
@@ -62,12 +66,16 @@ export class Kernel {
         const tasks = new PerKeyTaskQueue(options.logger)
         const api = createBotApi(options.client, sender)
 
+        this.api = api
         this.tasks = tasks
         this.router = new Router({
             sender,
             roles,
             gate,
             logger: options.logger,
+            ...(options.onEvent !== undefined
+                ? { onEvent: options.onEvent }
+                : {}),
         })
 
         let host: PluginHost
@@ -131,6 +139,22 @@ export class Kernel {
         return this.lifecycle.state
     }
 
+    get uptimeMs(): number {
+        return this.startedAt === null ? 0 : Date.now() - this.startedAt
+    }
+
+    get isConnected(): boolean {
+        return this.client.isConnected
+    }
+
+    listPlugins() {
+        return this.host.listStatus()
+    }
+
+    listCommands() {
+        return this.router.listCommands()
+    }
+
     start(): Promise<void> {
         return this.lifecycle.start()
     }

package/src/core/logging/log-buffer.ts

@@ -0,0 +1,109 @@
+import {
+    formatValue,
+    logLevelWeight,
+    type LogLevel,
+    type LogRecord,
+} from './logger.js'
+
+export interface LogEntry {
+    time: number
+    level: LogLevel
+    scope: string
+    message: string
+    args: string[]
+}
+
+export interface LogFilter {
+    level?: LogLevel | undefined
+    scope?: string | undefined
+    query?: string | undefined
+    limit?: number | undefined
+}
+
+export function matchesLogFilter(entry: LogEntry, filter: LogFilter): boolean {
+    if (
+        filter.level !== undefined &&
+        logLevelWeight(entry.level) < logLevelWeight(filter.level)
+    ) {
+        return false
+    }
+
+    if (
+        filter.scope !== undefined &&
+        filter.scope.length > 0 &&
+        entry.scope !== filter.scope
+    ) {
+        return false
+    }
+
+    if (filter.query !== undefined && filter.query.length > 0) {
+        const query = filter.query.toLowerCase()
+        const haystack = [entry.scope, entry.message, ...entry.args]
+            .join(' ')
+            .toLowerCase()
+
+        if (!haystack.includes(query)) return false
+    }
+
+    return true
+}
+
+export class LogBuffer {
+    private readonly entries: LogEntry[] = []
+    private readonly listeners = new Set<(entry: LogEntry) => void>()
+
+    constructor(private readonly capacity = 2_000) {}
+
+    get size(): number {
+        return this.entries.length
+    }
+
+    push(record: LogRecord): void {
+        const entry: LogEntry = {
+            time: record.time.getTime(),
+            level: record.level,
+            scope: record.scope,
+            message: record.message,
+            args: record.args.map(formatValue),
+        }
+
+        this.entries.push(entry)
+
+        if (this.entries.length > this.capacity) {
+            this.entries.splice(0, this.entries.length - this.capacity)
+        }
+
+        for (const listener of this.listeners) {
+            try {
+                listener(entry)
+            } catch {
+                // Log consumers must never break logging.
+            }
+        }
+    }
+
+    list(filter: LogFilter = {}): LogEntry[] {
+        const matched = this.entries.filter((entry) =>
+            matchesLogFilter(entry, filter)
+        )
+        const limit = filter.limit
+
+        if (limit === undefined || limit < 0 || limit >= matched.length) {
+            return matched
+        }
+
+        return matched.slice(-limit)
+    }
+
+    clear(): void {
+        this.entries.length = 0
+    }
+
+    subscribe(listener: (entry: LogEntry) => void): () => void {
+        this.listeners.add(listener)
+
+        return () => {
+            this.listeners.delete(listener)
+        }
+    }
+}

package/src/core/logging/logger.ts

@@ -34,7 +34,7 @@ export interface Logger {
     child(scope: string): Logger
 }
 
-function formatValue(value: unknown): string {
+export function formatValue(value: unknown): string {
     if (value instanceof Error) {
         return value.stack ?? `${value.name}: ${value.message}`
     }
@@ -49,7 +49,7 @@ function formatValue(value: unknown): string {
     }
 }
 
-const defaultSink: LogSink = (record) => {
+export const defaultLogSink: LogSink = (record) => {
     const time = record.time.toISOString()
     const scope = record.scope ? ` [${record.scope}]` : ''
     const args =
@@ -92,10 +92,14 @@ export function parseLogLevel(
     return normalized
 }
 
+export function logLevelWeight(level: LogLevel): number {
+    return LEVEL_WEIGHT[level]
+}
+
 export function createLogger(options: LoggerOptions = {}): Logger {
     const threshold = options.level ?? 'info'
     const scope = options.scope ?? 'bot'
-    const sink = options.sink ?? defaultSink
+    const sink = options.sink ?? defaultLogSink
 
     const emit = (level: LogLevel, message: string, args: unknown[]): void => {
         if (LEVEL_WEIGHT[level] < LEVEL_WEIGHT[threshold]) return

package/src/core/plugin/command-params.ts

@@ -1,7 +1,14 @@
-import { parseSegments } from '@snowluma/sdk'
+import { parseSegments, type OneBotMessageEvent } from '@snowluma/sdk'
 
 export type CommandParamType =
-    'string' | 'text' | 'number' | 'integer' | 'boolean' | 'at'
+    | 'string'
+    | 'text'
+    | 'number'
+    | 'integer'
+    | 'boolean'
+    | 'at'
+    | 'reply'
+    | 'time'
 
 export interface ParsedCommandParams {
     args: unknown[]
@@ -10,7 +17,7 @@ export interface ParsedCommandParams {
 
 export interface CompiledCommandParams {
     usage: string
-    parse(input: string): ParsedCommandParams
+    parse(input: string, event?: OneBotMessageEvent): ParsedCommandParams
 }
 
 export class CommandParamsError extends Error {
@@ -51,6 +58,8 @@ function parseType(value: string): CommandParamType {
         case 'integer':
         case 'boolean':
         case 'at':
+        case 'reply':
+        case 'time':
             return value
         default:
             throw declarationError(`未知的参数类型 "${value}"`)
@@ -209,6 +218,127 @@ function parseAt(value: string, name: string, usage: string): number {
     )
 }
 
+const TIME_UNITS: Record<string, number> = {
+    s: 1,
+    秒: 1,
+    m: 60,
+    分: 60,
+    分钟: 60,
+    h: 3600,
+    时: 3600,
+    小时: 3600,
+    d: 86400,
+    天: 86400,
+    w: 604800,
+    周: 604800,
+}
+
+const TIME_PART = /^(\d+(?:\.\d+)?)(分钟|小时|秒|分|时|天|周|[smhdw])/i
+
+function parseTimeValue(value: string): number | null {
+    const raw = value.trim()
+
+    if (/^\d+$/.test(raw)) {
+        const seconds = Number(raw)
+
+        return Number.isSafeInteger(seconds) ? seconds : null
+    }
+
+    let index = 0
+    let total = 0
+    let parsed = false
+
+    while (index < raw.length) {
+        const match = TIME_PART.exec(raw.slice(index))
+
+        if (!match) return null
+
+        const unit = TIME_UNITS[match[2]?.toLowerCase() ?? '']
+        const amount = Number(match[1])
+
+        if (unit === undefined) return null
+
+        total += amount * unit
+        index += match[0].length
+        parsed = true
+    }
+
+    if (!parsed || !Number.isSafeInteger(total) || total < 0) {
+        return null
+    }
+
+    return total
+}
+
+function parseTime(value: string, name: string, usage: string): number {
+    const seconds = parseTimeValue(value)
+
+    if (seconds === null) {
+        throw new CommandParamsError(
+            `参数 ${name} 需要是时间，例如 10s、5m、1h30m`,
+            usage
+        )
+    }
+
+    return seconds
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function toMessageId(value: unknown): number | undefined {
+    const raw = typeof value === 'string' ? value.trim() : value
+
+    if (typeof raw !== 'number' && typeof raw !== 'string') {
+        return undefined
+    }
+
+    const parsed =
+        typeof raw === 'string'
+            ? /^-?\d+$/.test(raw)
+                ? Number(raw)
+                : Number.NaN
+            : raw
+
+    return Number.isSafeInteger(parsed) && parsed !== 0 ? parsed : undefined
+}
+
+function replyIdIn(segments: readonly unknown[]): number | undefined {
+    for (const segment of segments) {
+        if (!isRecord(segment) || segment.type !== 'reply') continue
+
+        const data = isRecord(segment.data) ? segment.data : undefined
+        const id = toMessageId(data?.id)
+
+        if (id !== undefined) return id
+    }
+
+    return undefined
+}
+
+function quoteIdOf(event: OneBotMessageEvent | undefined): number | undefined {
+    if (!event) return undefined
+
+    const message = event.message
+
+    if (typeof message === 'string') {
+        const id = replyIdIn(parseSegments(message))
+
+        if (id !== undefined) return id
+    } else if (Array.isArray(message)) {
+        const id = replyIdIn(message)
+
+        if (id !== undefined) return id
+    } else if (isRecord(message)) {
+        const id = replyIdIn([message])
+
+        if (id !== undefined) return id
+    }
+
+    return replyIdIn(parseSegments(event.raw_message))
+}
+
 function parseDefaultValue(
     type: CommandParamType,
     raw: string,
@@ -248,7 +378,17 @@ function parseDefaultValue(
             return boolean
         }
         case 'at':
+        case 'reply':
             throw declarationError(`参数 ${name} 不支持默认值`)
+        case 'time': {
+            const seconds = parseTimeValue(value)
+
+            if (seconds === null) {
+                throw declarationError(`参数 ${name} 的默认值不是时间`)
+            }
+
+            return seconds
+        }
     }
 }
 
@@ -526,19 +666,37 @@ function parseValue(spec: ParamSpec, raw: string, usage: string): unknown {
         }
         case 'at':
             return parseAt(raw, spec.name, usage)
+        case 'time':
+            return parseTime(raw, spec.name, usage)
     }
 }
 
 function parseInput(
     specs: ParamSpec[],
     input: string,
-    usage: string
+    usage: string,
+    quoteId: number | undefined
 ): ParsedCommandParams {
     const tokens = tokenizeInput(input, usage)
     const args: unknown[] = []
     let index = 0
 
     for (const spec of specs) {
+        if (spec.type === 'reply') {
+            if (quoteId !== undefined) {
+                args.push(quoteId)
+            } else if (spec.required) {
+                throw new CommandParamsError(
+                    `参数 ${spec.name} 需要引用一条消息`,
+                    usage
+                )
+            } else {
+                args.push(undefined)
+            }
+
+            continue
+        }
+
         if (spec.rest) {
             for (
                 let tokenIndex = index;
@@ -634,8 +792,8 @@ export function compileCommandParams(
 
     return {
         usage,
-        parse(input: string): ParsedCommandParams {
-            return parseInput(specs, input, usage)
+        parse(input: string, event?: OneBotMessageEvent): ParsedCommandParams {
+            return parseInput(specs, input, usage, quoteIdOf(event))
         },
     }
 }
@@ -653,7 +811,7 @@ type Trim<Source extends string> = TrimLeft<TrimRight<Source>>
 type ParamValue<Type extends string> =
     Trim<Type> extends 'string' | 'text'
         ? string
-        : Trim<Type> extends 'number' | 'integer' | 'at'
+        : Trim<Type> extends 'number' | 'integer' | 'at' | 'reply' | 'time'
           ? number
           : Trim<Type> extends 'boolean'
             ? boolean

package/src/core/storage/session.ts

@@ -26,6 +26,21 @@ export interface SessionStore {
     clear(sessionId: string): Promise<void>
 }
 
+export interface SessionSummary {
+    sessionId: string
+    provider?: string | undefined
+    model?: string | undefined
+    persona?: string | undefined
+    messageCount: number
+    updatedAt: number
+}
+
+export interface SessionListOptions {
+    limit?: number | undefined
+    offset?: number | undefined
+    query?: string | undefined
+}
+
 interface SessionRow {
     session_id: string
     provider: string | null
@@ -35,6 +50,15 @@ interface SessionRow {
     updated_at: number
 }
 
+interface SessionSummaryRow {
+    session_id: string
+    provider: string | null
+    model: string | null
+    persona: string | null
+    message_count: number
+    updated_at: number
+}
+
 function isSessionRole(value: unknown): value is SessionRole {
     return value === 'system' || value === 'user' || value === 'assistant'
 }
@@ -79,6 +103,29 @@ function toState(row: SessionRow): SessionState {
     }
 }
 
+function toSummary(row: SessionSummaryRow): SessionSummary {
+    return {
+        sessionId: row.session_id,
+        ...(row.provider !== null ? { provider: row.provider } : {}),
+        ...(row.model !== null ? { model: row.model } : {}),
+        ...(row.persona !== null ? { persona: row.persona } : {}),
+        messageCount: row.message_count,
+        updatedAt: row.updated_at,
+    }
+}
+
+function clampLimit(value: number | undefined, fallback: number): number {
+    if (value === undefined || !Number.isFinite(value)) return fallback
+
+    return Math.min(Math.max(Math.trunc(value), 1), 500)
+}
+
+function clampOffset(value: number | undefined): number {
+    if (value === undefined || !Number.isFinite(value)) return 0
+
+    return Math.max(Math.trunc(value), 0)
+}
+
 export class SqliteSessionStore implements SessionStore {
     constructor(private readonly database: Database) {}
 
@@ -167,4 +214,52 @@ export class SqliteSessionStore implements SessionStore {
             .prepare('DELETE FROM sessions WHERE session_id = ?')
             .run(sessionId)
     }
+
+    async list(options: SessionListOptions = {}): Promise<SessionSummary[]> {
+        const limit = clampLimit(options.limit, 50)
+        const offset = clampOffset(options.offset)
+        const query = options.query?.trim()
+
+        const rows = (query
+            ? this.database.connection
+                  .prepare(
+                      `SELECT session_id, provider, model, persona,
+                                  json_array_length(messages) AS message_count,
+                                  updated_at
+                           FROM sessions
+                           WHERE session_id LIKE ?
+                           ORDER BY updated_at DESC
+                           LIMIT ? OFFSET ?`
+                  )
+                  .all(`%${query}%`, limit, offset)
+            : this.database.connection
+                  .prepare(
+                      `SELECT session_id, provider, model, persona,
+                                  json_array_length(messages) AS message_count,
+                                  updated_at
+                           FROM sessions
+                           ORDER BY updated_at DESC
+                           LIMIT ? OFFSET ?`
+                  )
+                  .all(limit, offset)) as unknown as SessionSummaryRow[]
+
+        return rows.map(toSummary)
+    }
+
+    async count(query?: string): Promise<number> {
+        const value = query?.trim()
+        const row = (
+            value
+                ? this.database.connection
+                      .prepare(
+                          'SELECT COUNT(*) AS count FROM sessions WHERE session_id LIKE ?'
+                      )
+                      .get(`%${value}%`)
+                : this.database.connection
+                      .prepare('SELECT COUNT(*) AS count FROM sessions')
+                      .get()
+        ) as { count: number } | undefined
+
+        return row?.count ?? 0
+    }
 }