@jsbot-tellus/core 2.5.0 → 2.6.0

package/src/core/web/routes/actions.ts

@@ -0,0 +1,43 @@
+import { HttpError, readJsonBody, sendData } from '../http.js'
+import { asRecord, requireRuntime, type ApiContext } from './shared.js'
+
+export async function handleActions(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    const action = body['action']
+
+    if (
+        typeof action !== 'string' ||
+        action.length === 0 ||
+        action.length > 128
+    ) {
+        throw new HttpError(400, 'action is required')
+    }
+
+    const runtime = requireRuntime(ctx.deps)
+    const params = body['params'] ?? undefined
+    const result = await runtime.api.call(action as never, params as never)
+
+    sendData(ctx.res, 200, { result: result ?? null })
+}
+
+export async function handleRuntimeCommand(ctx: ApiContext): Promise<void> {
+    if (ctx.pathname.endsWith('/restart')) {
+        sendData(ctx.res, 200, {
+            ok: await ctx.deps.restart(),
+        })
+
+        return
+    }
+
+    if (ctx.pathname.endsWith('/pause')) {
+        ctx.deps.pause()
+        sendData(ctx.res, 200, { ok: true })
+
+        return
+    }
+
+    if (ctx.pathname.endsWith('/resume')) {
+        ctx.deps.resume()
+        sendData(ctx.res, 200, { ok: true })
+    }
+}

package/src/core/web/routes/config.ts

@@ -0,0 +1,42 @@
+import { maskConfig } from '../config-store.js'
+import { readJsonBody, sendData } from '../http.js'
+import { asRecord, type ApiContext } from './shared.js'
+
+export async function handleConfigGet(ctx: ApiContext): Promise<void> {
+    const document = await ctx.deps.readConfig()
+    const masked = maskConfig(document.config)
+
+    sendData(ctx.res, 200, {
+        config: masked.config,
+        meta: {
+            path: document.path,
+            hash: document.hash,
+            accessTokenSet: masked.accessTokenSet,
+            webuiPasswordSet: masked.webuiPasswordSet,
+        },
+    })
+}
+
+export async function handleConfigValidate(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    const result = await ctx.deps.validateConfig(body['config'])
+
+    sendData(ctx.res, 200, {
+        ok: result.ok,
+        issues: result.issues,
+    })
+}
+
+export async function handleConfigPut(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    const baseHash = body['baseHash']
+
+    sendData(
+        ctx.res,
+        200,
+        await ctx.deps.applyConfig(
+            body['config'],
+            typeof baseHash === 'string' ? baseHash : undefined
+        )
+    )
+}

package/src/core/web/routes/kv.ts

@@ -0,0 +1,122 @@
+import { SqlitePluginKV } from '../../plugin/kv.js'
+import { HttpError, readJsonBody, sendData } from '../http.js'
+import {
+    asRecord,
+    clampInt,
+    requireRuntime,
+    type ApiContext,
+} from './shared.js'
+
+function assertPluginId(value: string): string {
+    if (!/^\w[\w.-]*$/.test(value)) {
+        throw new HttpError(400, `invalid plugin id: ${value}`)
+    }
+
+    return value
+}
+
+function assertKey(value: string): string {
+    if (value.length === 0 || value.length > 512) {
+        throw new HttpError(400, 'invalid key length')
+    }
+
+    return value
+}
+
+function parseKvValue(value: string): unknown {
+    try {
+        return JSON.parse(value) as unknown
+    } catch {
+        return value
+    }
+}
+
+interface KvRow {
+    key: string
+    value: string
+    updated_at: number
+}
+
+export async function handleKvPlugins(ctx: ApiContext): Promise<void> {
+    const runtime = requireRuntime(ctx.deps)
+    const rows = runtime.database.connection
+        .prepare(
+            'SELECT plugin_id, COUNT(*) AS count FROM plugin_kv GROUP BY plugin_id ORDER BY plugin_id'
+        )
+        .all() as Array<{ plugin_id: string; count: number }>
+
+    sendData(
+        ctx.res,
+        200,
+        rows.map((row) => ({ pluginId: row.plugin_id, count: row.count }))
+    )
+}
+
+export async function handleKvList(ctx: ApiContext): Promise<void> {
+    const runtime = requireRuntime(ctx.deps)
+    const pluginId = assertPluginId(ctx.search.get('pluginId') ?? '')
+    const prefix = ctx.search.get('prefix') ?? ''
+    const limit = clampInt(ctx.search.get('limit'), 100, 1, 500)
+    const offset = clampInt(ctx.search.get('offset'), 0, 0, 10_000_000)
+    const pattern =
+        prefix === ''
+            ? '%'
+            : `${prefix.replace(/[%_]/g, (match) => `\\${match}`)}%`
+    const rows = runtime.database.connection
+        .prepare(
+            `SELECT key, value, updated_at FROM plugin_kv
+             WHERE plugin_id = ? AND key LIKE ? ESCAPE '\\'
+             ORDER BY key
+             LIMIT ? OFFSET ?`
+        )
+        .all(pluginId, pattern, limit, offset) as unknown as KvRow[]
+    const totalRow = runtime.database.connection
+        .prepare(
+            `SELECT COUNT(*) AS count FROM plugin_kv
+             WHERE plugin_id = ? AND key LIKE ? ESCAPE '\\'`
+        )
+        .get(pluginId, pattern) as { count: number } | undefined
+
+    sendData(ctx.res, 200, {
+        items: rows.map((row) => ({
+            pluginId,
+            key: row.key,
+            value: parseKvValue(row.value),
+            updatedAt: row.updated_at,
+        })),
+        total: totalRow?.count ?? 0,
+        limit,
+        offset,
+    })
+}
+
+export async function handleKvPut(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    const runtime = requireRuntime(ctx.deps)
+    const pluginId = assertPluginId(
+        typeof body['pluginId'] === 'string' ? body['pluginId'] : ''
+    )
+    const key = assertKey(typeof body['key'] === 'string' ? body['key'] : '')
+
+    if (typeof body['value'] === 'function') {
+        throw new HttpError(400, 'invalid value')
+    }
+
+    await new SqlitePluginKV(runtime.database, pluginId).set(
+        key,
+        body['value'] as never
+    )
+
+    sendData(ctx.res, 200, { ok: true })
+}
+
+export async function handleKvDelete(ctx: ApiContext): Promise<void> {
+    const runtime = requireRuntime(ctx.deps)
+    const pluginId = assertPluginId(ctx.search.get('pluginId') ?? '')
+    const key = assertKey(ctx.search.get('key') ?? '')
+    const deleted = await new SqlitePluginKV(runtime.database, pluginId).delete(
+        key
+    )
+
+    sendData(ctx.res, 200, { ok: deleted })
+}

package/src/core/web/routes/plugins.ts

@@ -0,0 +1,151 @@
+import { stripPluginEnvelope } from '../../plugin/host.js'
+import { HttpError, isRecord, readJsonBody, sendData } from '../http.js'
+import { asRecord, requireRuntime, type ApiContext } from './shared.js'
+
+const ENVELOPE_KEYS = new Set(['enabled', 'private', 'groups'])
+
+export async function handlePluginsList(ctx: ApiContext): Promise<void> {
+    const runtime = requireRuntime(ctx.deps)
+    const statuses = new Map(
+        runtime.kernel.listPlugins().map((entry) => [entry.id, entry])
+    )
+    const plugins = runtime.plugins.map((definition) => {
+        const id = definition.manifest.id
+        const status = statuses.get(id)
+        const envelope = asRecord(runtime.config.plugins[id]) as Record<
+            string,
+            unknown
+        >
+
+        return {
+            id,
+            version: definition.manifest.version,
+            description: definition.manifest.description,
+            dependencies: definition.manifest.dependencies ?? [],
+            defaultEnabled: definition.manifest.defaultEnabled ?? false,
+            enabled: status?.enabled ?? false,
+            loaded: status?.loaded ?? false,
+            config: envelope,
+            options: stripPluginEnvelope(envelope as never) as Record<
+                string,
+                unknown
+            >,
+        }
+    })
+    const installed = runtime.installer.enabled
+        ? await runtime.installer.list()
+        : []
+
+    sendData(ctx.res, 200, {
+        plugins,
+        installed,
+        installerEnabled: runtime.installer.enabled,
+        configHash: (await ctx.deps.readConfig()).hash,
+    })
+}
+
+export async function handlePluginConfigPut(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    const id = ctx.segments[2]
+    const document = await ctx.deps.readConfig()
+
+    if (id === undefined) throw new HttpError(404, 'unknown plugin')
+
+    if (!isRecord(document.config.plugins[id])) {
+        throw new HttpError(404, `unknown plugin: ${id}`)
+    }
+
+    const existing = asRecord(document.config.plugins[id]) as unknown as Record<
+        string,
+        unknown
+    >
+    const next = { ...existing }
+
+    if (typeof body['enabled'] === 'boolean') {
+        next['enabled'] = body['enabled']
+    }
+
+    if (typeof body['private'] === 'boolean') {
+        next['private'] = body['private']
+    }
+
+    if (body['groups'] !== undefined) next['groups'] = body['groups']
+
+    if (body['options'] !== undefined) {
+        if (!isRecord(body['options'])) {
+            throw new HttpError(400, 'options must be an object')
+        }
+
+        for (const key of Object.keys(next)) {
+            if (!ENVELOPE_KEYS.has(key)) delete next[key]
+        }
+
+        for (const [key, value] of Object.entries(body['options'])) {
+            if (!ENVELOPE_KEYS.has(key)) next[key] = value
+        }
+    }
+
+    const config = {
+        ...document.config,
+        plugins: {
+            ...document.config.plugins,
+            [id]: next,
+        },
+    }
+    const baseHash = body['baseHash']
+
+    sendData(
+        ctx.res,
+        200,
+        await ctx.deps.applyConfig(
+            config,
+            typeof baseHash === 'string' ? baseHash : undefined
+        )
+    )
+}
+
+export async function handleInstallerAction(ctx: ApiContext): Promise<void> {
+    const runtime = requireRuntime(ctx.deps)
+
+    if (!runtime.installer.enabled) {
+        throw new HttpError(403, '插件安装器未启用')
+    }
+
+    const body = asRecord(await readJsonBody(ctx.req))
+    const target = typeof body['target'] === 'string' ? body['target'] : ''
+    const spec = typeof body['spec'] === 'string' ? body['spec'] : ''
+
+    if (ctx.pathname.endsWith('/install')) {
+        if (!spec) throw new HttpError(400, 'spec is required')
+
+        sendData(
+            ctx.res,
+            200,
+            await ctx.deps.runExclusive(() => runtime.installer.install(spec))
+        )
+
+        return
+    }
+
+    if (ctx.pathname.endsWith('/update')) {
+        sendData(
+            ctx.res,
+            200,
+            await ctx.deps.runExclusive(() =>
+                runtime.installer.update(target || undefined)
+            )
+        )
+
+        return
+    }
+
+    sendData(
+        ctx.res,
+        200,
+        await ctx.deps.runExclusive(async () =>
+            runtime.installer.remove(target, undefined, {
+                force: body['force'] === true,
+            })
+        )
+    )
+}

package/src/core/web/routes/sessions.ts

@@ -0,0 +1,188 @@
+import {
+    SqliteSessionStore,
+    type SessionMessage,
+    type SessionRole,
+    type SessionState,
+} from '../../storage/session.js'
+import { HttpError, isRecord, readJsonBody, sendData } from '../http.js'
+import {
+    asRecord,
+    clampInt,
+    requireRuntime,
+    type ApiContext,
+} from './shared.js'
+
+const MAX_SESSION_MESSAGES = 10_000
+
+function parseSessionMessages(value: unknown): SessionMessage[] {
+    if (!Array.isArray(value)) {
+        throw new HttpError(400, 'messages must be an array')
+    }
+
+    if (value.length > MAX_SESSION_MESSAGES) {
+        throw new HttpError(400, 'messages too long')
+    }
+
+    return value.map((item, index) => {
+        if (!isRecord(item)) {
+            throw new HttpError(400, `invalid message at index ${index}`)
+        }
+
+        const role = item['role']
+        const content = item['content']
+        const at = item['at']
+
+        if (role !== 'system' && role !== 'user' && role !== 'assistant') {
+            throw new HttpError(400, `invalid message role at index ${index}`)
+        }
+
+        if (typeof content !== 'string') {
+            throw new HttpError(
+                400,
+                `invalid message content at index ${index}`
+            )
+        }
+
+        if (typeof at !== 'number' || !Number.isFinite(at)) {
+            throw new HttpError(400, `invalid message time at index ${index}`)
+        }
+
+        return { role: role as SessionRole, content, at }
+    })
+}
+
+function clearableString(
+    value: unknown,
+    fallback: string | undefined
+): string | undefined {
+    if (value === null) return undefined
+    if (value === undefined) return fallback
+    if (typeof value === 'string' && value.trim().length > 0) {
+        return value
+    }
+
+    return undefined
+}
+
+export async function handleSessionList(ctx: ApiContext): Promise<void> {
+    const runtime = requireRuntime(ctx.deps)
+    const store = new SqliteSessionStore(runtime.database)
+    const limit = clampInt(ctx.search.get('limit'), 50, 1, 200)
+    const offset = clampInt(ctx.search.get('offset'), 0, 0, 10_000_000)
+    const query = ctx.search.get('query')?.slice(0, 200) || undefined
+    const items = await store.list({ limit, offset, query })
+    const total = await store.count(query)
+
+    sendData(ctx.res, 200, { items, total, limit, offset })
+}
+
+function sessionIdOf(ctx: ApiContext): string {
+    const id = ctx.segments[2]
+
+    if (!id) throw new HttpError(404, 'session not found')
+
+    return id
+}
+
+function requireSessionStore(ctx: ApiContext): SqliteSessionStore {
+    const runtime = requireRuntime(ctx.deps)
+
+    return new SqliteSessionStore(runtime.database)
+}
+
+async function sessionDetail(ctx: ApiContext): Promise<SessionState> {
+    const id = sessionIdOf(ctx)
+    const state = await requireSessionStore(ctx).get(id)
+
+    if (!state) throw new HttpError(404, 'session not found')
+
+    return state
+}
+
+export async function handleSessionGet(ctx: ApiContext): Promise<void> {
+    sendData(ctx.res, 200, await sessionDetail(ctx))
+}
+
+export async function handleSessionPut(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    await sessionDetail(ctx)
+
+    const messages =
+        body['messages'] === undefined
+            ? undefined
+            : parseSessionMessages(body['messages'])
+
+    const baseline = await sessionDetail(ctx)
+    const state: SessionState = {
+        sessionId: sessionIdOf(ctx),
+        provider: clearableString(body['provider'], baseline.provider),
+        model: clearableString(body['model'], baseline.model),
+        persona: clearableString(body['persona'], baseline.persona),
+        messages: messages ?? baseline.messages,
+        updatedAt: Date.now(),
+    }
+
+    await requireSessionStore(ctx).save(state)
+    sendData(ctx.res, 200, state)
+}
+
+export async function handleSessionMessages(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    const role = body['role']
+    const content = body['content']
+
+    if (role !== 'system' && role !== 'user' && role !== 'assistant') {
+        throw new HttpError(400, 'invalid message role')
+    }
+
+    if (
+        typeof content !== 'string' ||
+        content.length === 0 ||
+        content.length > 100_000
+    ) {
+        throw new HttpError(400, 'invalid message content')
+    }
+
+    const state = await sessionDetail(ctx)
+    const message = { role: role as SessionRole, content, at: Date.now() }
+    const next: SessionState = {
+        ...state,
+        messages: [...state.messages, message],
+        updatedAt: Date.now(),
+    }
+
+    await requireSessionStore(ctx).save(next)
+    sendData(ctx.res, 200, next)
+}
+
+export async function handleSessionSend(ctx: ApiContext): Promise<void> {
+    const body = asRecord(await readJsonBody(ctx.req))
+    const id = sessionIdOf(ctx)
+    const message = body['message']
+    const autoEscape = body['autoEscape']
+
+    if (
+        typeof message !== 'string' ||
+        message.length === 0 ||
+        message.length > 20_000
+    ) {
+        throw new HttpError(400, 'invalid message')
+    }
+
+    const runtime = requireRuntime(ctx.deps)
+
+    await sessionDetail(ctx)
+
+    const result = await runtime.api.send(
+        id,
+        message,
+        typeof autoEscape === 'boolean' ? { autoEscape } : undefined
+    )
+
+    sendData(ctx.res, 200, { result: result ?? null })
+}
+
+export async function handleSessionDelete(ctx: ApiContext): Promise<void> {
+    await requireSessionStore(ctx).clear(sessionIdOf(ctx))
+    sendData(ctx.res, 200, { cleared: true })
+}

package/src/core/web/routes/shared.ts

@@ -0,0 +1,42 @@
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { AuthSession } from '../auth.js'
+import { HttpError, isRecord, type URLSearchParamsLike } from '../http.js'
+import type { WebUiDeps, WebUiRuntime } from '../types.js'
+
+export interface ApiContext {
+    deps: WebUiDeps
+    req: IncomingMessage
+    res: ServerResponse
+    method: string
+    pathname: string
+    segments: string[]
+    search: URLSearchParamsLike
+    session: AuthSession
+}
+
+export function requireRuntime(deps: WebUiDeps): WebUiRuntime {
+    const runtime = deps.getRuntime()
+
+    if (!runtime) throw new HttpError(503, '运行时不可用，请稍后再试')
+
+    return runtime
+}
+
+export function clampInt(
+    value: string | null,
+    fallback: number,
+    min: number,
+    max: number
+): number {
+    if (value === null) return fallback
+
+    const parsed = Number.parseInt(value, 10)
+
+    if (!Number.isFinite(parsed)) return fallback
+
+    return Math.min(Math.max(parsed, min), max)
+}
+
+export function asRecord(value: unknown): Record<string, unknown> {
+    return isRecord(value) ? value : {}
+}