@jsbot-tellus/core 2.3.0 → 2.4.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/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
+    }
 }