mioku-service-webui 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jerry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# mioku-service-webui
+为 mioku 提供web-ui服务

package/auth.ts

@@ -0,0 +1,48 @@
+import * as crypto from "node:crypto";
+import type { Context, Next } from "hono";
+import type { AuthConfig } from "./types";
+import { AUTH_PATH, WEEK_MS, readJsonFile, writeJsonFile } from "./utils";
+
+export function ensureAuthConfig(): AuthConfig {
+  const now = Date.now();
+  const existing = readJsonFile<AuthConfig | null>(AUTH_PATH, null);
+
+  if (!existing || !existing.token || !existing.expiresAt || existing.expiresAt <= now) {
+    const generated: AuthConfig = {
+      token: crypto.randomBytes(24).toString("hex"),
+      createdAt: now,
+      expiresAt: now + WEEK_MS,
+    };
+    writeJsonFile(AUTH_PATH, generated);
+    return generated;
+  }
+
+  return existing;
+}
+
+export function verifyAuthHeader(c: Context): boolean {
+  const auth = c.req.header("authorization") || "";
+  const token = auth.replace(/^Bearer\s+/i, "").trim();
+  if (!token) {
+    return false;
+  }
+
+  const authConfig = ensureAuthConfig();
+  return token === authConfig.token && Date.now() < authConfig.expiresAt;
+}
+
+export async function requireAuth(c: Context, next: Next): Promise<Response | void> {
+  if (!verifyAuthHeader(c)) {
+    return c.json({ ok: false, error: "UNAUTHORIZED" }, 401);
+  }
+  await next();
+}
+
+export function loginWithToken(inputToken: string): { ok: boolean; expiresAt?: number } {
+  const authConfig = ensureAuthConfig();
+  if (inputToken !== authConfig.token) {
+    return { ok: false };
+  }
+
+  return { ok: true, expiresAt: authConfig.expiresAt };
+}

package/config-page-loader.ts

@@ -0,0 +1,109 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import matter from "gray-matter";
+import { logger } from "mioki";
+
+export interface ConfigField {
+  key: string;
+  label: string;
+  type: "text" | "textarea" | "number" | "switch" | "select" | "multi-select" | "secret" | "json";
+  description?: string;
+  placeholder?: string;
+  required?: boolean;
+  multiple?: boolean;
+  source?: string;
+  options?: Array<{ value: string; label: string }>;
+  defaultValue?: any;
+}
+
+export interface ConfigPageManifest {
+  plugin: string;
+  title: string;
+  description?: string;
+  markdown: string;
+  fields: ConfigField[];
+  hasCustomPage: boolean;
+}
+
+export function loadPluginConfigPage(pluginName: string): ConfigPageManifest | null {
+  const pluginDir = path.join(process.cwd(), "plugins", pluginName);
+  const configMdPath = path.join(pluginDir, "config.md");
+
+  if (!fs.existsSync(configMdPath)) {
+    return null;
+  }
+
+  try {
+    const fileContent = fs.readFileSync(configMdPath, "utf-8");
+    const parsed = matter(fileContent);
+
+    const frontmatter = parsed.data as any;
+    const fields = (frontmatter.fields || []) as ConfigField[];
+
+    // Validate fields
+    for (const field of fields) {
+      if (!field.key || !field.label || !field.type) {
+        logger.warn(`Invalid field in ${pluginName}/config.md: missing key, label, or type`);
+        continue;
+      }
+
+      // Validate key format: <configName>.<jsonPath>
+      if (!field.key.includes(".")) {
+        logger.warn(`Invalid field key in ${pluginName}/config.md: ${field.key} (must be <configName>.<path>)`);
+      }
+    }
+
+    return {
+      plugin: pluginName,
+      title: frontmatter.title || `${pluginName} Configuration`,
+      description: frontmatter.description,
+      markdown: parsed.content,
+      fields,
+      hasCustomPage: true,
+    };
+  } catch (error: any) {
+    logger.error(`Failed to load config page for ${pluginName}: ${error.message}`);
+    return null;
+  }
+}
+
+export function parseConfigKey(key: string): { configName: string; path: string } | null {
+  const parts = key.split(".");
+  if (parts.length < 2) {
+    return null;
+  }
+
+  return {
+    configName: parts[0],
+    path: parts.slice(1).join("."),
+  };
+}
+
+export function getValueByPath(obj: any, path: string): any {
+  const keys = path.split(".");
+  let current = obj;
+
+  for (const key of keys) {
+    if (current == null || typeof current !== "object") {
+      return undefined;
+    }
+    current = current[key];
+  }
+
+  return current;
+}
+
+export function setValueByPath(obj: any, path: string, value: any): void {
+  const keys = path.split(".");
+  let current = obj;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[keys[keys.length - 1]] = value;
+}

package/database.ts

@@ -0,0 +1,322 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import Database from "better-sqlite3";
+import { CHAT_DATA_DIR, readJsonFile, writeJsonFile } from "./utils";
+
+const DB_PATH = path.join(CHAT_DATA_DIR, "chat.db");
+const SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function openDb(): any {
+  if (!fs.existsSync(DB_PATH)) {
+    throw new Error("数据库不存在");
+  }
+  return new Database(DB_PATH, { readonly: false });
+}
+
+function getTableColumns(db: any, table: string): string[] {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.map((row) => row.name);
+}
+
+function ensureSafeIdentifier(value: string, label: string): string {
+  if (!SAFE_IDENTIFIER.test(value)) {
+    throw new Error(`${label} 非法`);
+  }
+  return value;
+}
+
+function resolveTimeColumn(columns: string[]): string | null {
+  if (columns.includes("created_at")) return "created_at";
+  if (columns.includes("timestamp")) return "timestamp";
+  if (columns.includes("updated_at")) return "updated_at";
+  return null;
+}
+
+export function listTables(): string[] {
+  const db = openDb();
+  try {
+    const rows = db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all() as Array<{ name: string }>;
+    return rows.map((row) => row.name);
+  } finally {
+    db.close();
+  }
+}
+
+export function queryMessages(input: {
+  table?: string;
+  keyword?: string;
+  userId?: string;
+  sessionId?: string;
+  startTime?: number;
+  endTime?: number;
+  page?: number;
+  pageSize?: number;
+}): Record<string, any> {
+  const db = openDb();
+  try {
+    const table = ensureSafeIdentifier(input.table || "messages", "表名");
+    const columns = getTableColumns(db, table);
+    const timeColumn = resolveTimeColumn(columns);
+
+    const page = Math.max(1, Number(input.page || 1));
+    const pageSize = Math.min(200, Math.max(1, Number(input.pageSize || 20)));
+    const offset = (page - 1) * pageSize;
+
+    const conditions: string[] = [];
+    const params: Record<string, any> = {};
+
+    if (input.keyword && columns.includes("content")) {
+      conditions.push("content LIKE @keyword");
+      params.keyword = `%${input.keyword}%`;
+    }
+    if (input.userId && columns.includes("user_id")) {
+      conditions.push("user_id = @userId");
+      params.userId = input.userId;
+    }
+    if (input.sessionId && columns.includes("session_id")) {
+      conditions.push("session_id = @sessionId");
+      params.sessionId = input.sessionId;
+    }
+    if (input.startTime && timeColumn) {
+      conditions.push(`${timeColumn} >= @startTime`);
+      params.startTime = input.startTime;
+    }
+    if (input.endTime && timeColumn) {
+      conditions.push(`${timeColumn} <= @endTime`);
+      params.endTime = input.endTime;
+    }
+
+    const whereSql = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+
+    const countStmt = db.prepare(`SELECT COUNT(*) as count FROM ${table} ${whereSql}`);
+    const total = Number((countStmt.get(params) as any)?.count || 0);
+
+    const orderField = timeColumn || columns[0] || "rowid";
+    const rowsStmt = db.prepare(`SELECT * FROM ${table} ${whereSql} ORDER BY ${orderField} DESC LIMIT @limit OFFSET @offset`);
+    const rows = rowsStmt.all({ ...params, limit: pageSize, offset });
+
+    return { total, page, pageSize, rows, table, columns };
+  } finally {
+    db.close();
+  }
+}
+
+export function updateMessage(input: { table?: string; idField?: string; id: string | number; content: string }): Record<string, any> {
+  const db = openDb();
+  try {
+    const table = ensureSafeIdentifier(input.table || "messages", "表名");
+    const idField = ensureSafeIdentifier(input.idField || "id", "主键字段");
+    const stmt = db.prepare(`UPDATE ${table} SET content = ? WHERE ${idField} = ?`);
+    const result = stmt.run(input.content, input.id);
+    return { changed: result.changes };
+  } finally {
+    db.close();
+  }
+}
+
+export function deleteMessagesByRange(input: { table?: string; startTime: number; endTime: number }): Record<string, any> {
+  const db = openDb();
+  try {
+    const table = ensureSafeIdentifier(input.table || "messages", "表名");
+    const columns = getTableColumns(db, table);
+    const timeColumn = resolveTimeColumn(columns);
+    if (!timeColumn) {
+      throw new Error(`${table} 不包含时间字段(created_at/timestamp/updated_at)`);
+    }
+    const stmt = db.prepare(`DELETE FROM ${table} WHERE ${timeColumn} >= ? AND ${timeColumn} <= ?`);
+    const result = stmt.run(input.startTime, input.endTime);
+    return { deleted: result.changes };
+  } finally {
+    db.close();
+  }
+}
+
+export function getStats(): Record<string, any> {
+  const db = openDb();
+  try {
+    const tables = (db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all() as Array<{ name: string }>).map(
+      (row) => row.name,
+    );
+
+    const hasMessages = tables.includes("messages");
+    const hasImages = tables.includes("images");
+    const messageColumns = hasMessages ? getTableColumns(db, "messages") : [];
+    const messageTimeColumn = resolveTimeColumn(messageColumns);
+
+    const messageTotal = hasMessages ? Number((db.prepare("SELECT COUNT(*) as count FROM messages").get() as any)?.count || 0) : 0;
+    const activeUsers = hasMessages
+      ? Number((db.prepare("SELECT COUNT(DISTINCT user_id) as count FROM messages").get() as any)?.count || 0)
+      : 0;
+
+    const aiCalls = hasMessages
+      ? Number((db.prepare("SELECT COUNT(*) as count FROM messages WHERE role='assistant'").get() as any)?.count || 0)
+      : 0;
+
+    const timeline = hasMessages && messageTimeColumn
+      ? db
+          .prepare(
+            `SELECT strftime('%Y-%m-%d', datetime(${messageTimeColumn} / 1000, 'unixepoch')) as day, COUNT(*) as count FROM messages GROUP BY day ORDER BY day DESC LIMIT 30`,
+          )
+          .all()
+      : [];
+
+    const topTopics = hasMessages
+      ? db
+          .prepare(
+            "SELECT substr(content, 1, 20) as topic, COUNT(*) as count FROM messages WHERE content IS NOT NULL AND content != '' GROUP BY topic ORDER BY count DESC LIMIT 10",
+          )
+          .all()
+      : [];
+
+    const imageStats = hasImages
+      ? db
+          .prepare(
+            "SELECT COALESCE(NULLIF(TRIM(character), ''), 'unknown') || '/' || COALESCE(NULLIF(TRIM(emotion), ''), 'default') as name, COUNT(*) as count FROM images GROUP BY COALESCE(NULLIF(TRIM(character), ''), 'unknown'), COALESCE(NULLIF(TRIM(emotion), ''), 'default') ORDER BY count DESC LIMIT 20",
+          )
+          .all()
+      : [];
+
+    return {
+      messageTotal,
+      activeUsers,
+      aiCalls,
+      timeline,
+      topTopics,
+      imageStats,
+    };
+  } finally {
+    db.close();
+  }
+}
+
+export function exportData(format: "json" | "csv"): { filePath: string } {
+  const db = openDb();
+  try {
+    const tables = listTables();
+    const dump: Record<string, any[]> = {};
+
+    for (const table of tables) {
+      dump[table] = db.prepare(`SELECT * FROM ${table}`).all();
+    }
+
+    const backupDir = path.join(CHAT_DATA_DIR, "backup");
+    if (!fs.existsSync(backupDir)) {
+      fs.mkdirSync(backupDir, { recursive: true });
+    }
+
+    const ts = Date.now();
+    if (format === "json") {
+      const filePath = path.join(backupDir, `chat-backup-${ts}.json`);
+      fs.writeFileSync(filePath, JSON.stringify(dump, null, 2), "utf-8");
+      return { filePath };
+    }
+
+    const rows = dump.messages ?? [];
+    const headers = rows.length ? Object.keys(rows[0]) : [];
+    const csvLines = [headers.join(",")].concat(
+      rows.map((row) =>
+        headers
+          .map((key) => {
+            const raw = row[key] == null ? "" : String(row[key]);
+            return `"${raw.replace(/"/g, '""')}"`;
+          })
+          .join(","),
+      ),
+    );
+
+    const filePath = path.join(backupDir, `chat-backup-${ts}.csv`);
+    fs.writeFileSync(filePath, csvLines.join("\n"), "utf-8");
+    return { filePath };
+  } finally {
+    db.close();
+  }
+}
+
+export function importDataFromJson(filePath: string): { importedTables: string[] } {
+  const payload = readJsonFile<Record<string, any[]>>(filePath, {});
+  const db = openDb();
+
+  try {
+    const importedTables: string[] = [];
+
+    db.exec("BEGIN");
+    for (const [table, rows] of Object.entries(payload)) {
+      ensureSafeIdentifier(table, "表名");
+      if (!Array.isArray(rows) || rows.length === 0) {
+        continue;
+      }
+      const columns = Object.keys(rows[0]);
+      const placeholders = columns.map(() => "?").join(",");
+      const insert = db.prepare(
+        `INSERT INTO ${table} (${columns.join(",")}) VALUES (${placeholders})`,
+      );
+
+      for (const row of rows) {
+        insert.run(columns.map((column) => (row as any)[column]));
+      }
+      importedTables.push(table);
+    }
+    db.exec("COMMIT");
+
+    return { importedTables };
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  } finally {
+    db.close();
+  }
+}
+
+export function listMemeTree(): Record<string, Record<string, string[]>> {
+  const root = path.join(CHAT_DATA_DIR, "meme");
+  const tree: Record<string, Record<string, string[]>> = {};
+
+  if (!fs.existsSync(root)) {
+    return tree;
+  }
+
+  const characters = fs.readdirSync(root);
+  for (const character of characters) {
+    const charDir = path.join(root, character);
+    if (!fs.statSync(charDir).isDirectory()) {
+      continue;
+    }
+
+    tree[character] = {};
+    const emotions = fs.readdirSync(charDir);
+    for (const emotion of emotions) {
+      const emotionDir = path.join(charDir, emotion);
+      if (!fs.statSync(emotionDir).isDirectory()) {
+        continue;
+      }
+      tree[character][emotion] = fs
+        .readdirSync(emotionDir)
+        .filter((name) => /\.(png|jpg|jpeg|gif|webp)$/i.test(name))
+        .map((name) => path.join("data", "chat", "meme", character, emotion, name));
+    }
+  }
+
+  return tree;
+}
+
+export function savePluginConfig(pluginName: string, fileName: string, value: any): void {
+  const filePath = path.join(process.cwd(), "config", pluginName, `${fileName}.json`);
+  writeJsonFile(filePath, value);
+}
+
+export function getPluginConfigs(pluginName: string): Record<string, any> {
+  const pluginDir = path.join(process.cwd(), "config", pluginName);
+  if (!fs.existsSync(pluginDir)) {
+    return {};
+  }
+
+  const result: Record<string, any> = {};
+  const files = fs.readdirSync(pluginDir).filter((name) => name.endsWith(".json"));
+
+  for (const file of files) {
+    const filePath = path.join(pluginDir, file);
+    result[path.basename(file, ".json")] = readJsonFile(filePath, {});
+  }
+
+  return result;
+}

package/datasources.ts

@@ -0,0 +1,187 @@
+import { connectedBots, logger } from "mioki";
+
+export interface DatasourceOption {
+  value: string;
+  label: string;
+  description?: string;
+  meta?: Record<string, any>;
+}
+
+export interface DatasourceQuery {
+  q?: string;
+  limit?: number;
+}
+
+export type DatasourceProvider = (
+  query?: DatasourceQuery,
+) => Promise<DatasourceOption[]>;
+
+const datasources = new Map<string, DatasourceProvider>();
+
+export function registerDatasource(name: string, provider: DatasourceProvider): void {
+  datasources.set(name, provider);
+  logger.info(`Registered datasource: ${name}`);
+}
+
+function normalizeText(value: unknown): string {
+  return String(value ?? "").trim().toLowerCase();
+}
+
+function matchesQuery(option: DatasourceOption, query?: string): boolean {
+  const q = normalizeText(query);
+  if (!q) {
+    return true;
+  }
+
+  const haystacks = [
+    option.value,
+    option.label,
+    option.description,
+    option.meta?.searchText,
+    option.meta?.qq,
+    option.meta?.groupId,
+    option.meta?.nickname,
+    option.meta?.remark,
+    option.meta?.groupName,
+  ]
+    .map((item) => normalizeText(item))
+    .filter(Boolean);
+
+  return haystacks.some((item) => item.includes(q));
+}
+
+function limitOptions(
+  options: DatasourceOption[],
+  limit?: number,
+): DatasourceOption[] {
+  if (!limit || limit <= 0) {
+    return options;
+  }
+  return options.slice(0, limit);
+}
+
+export async function getDatasource(
+  name: string,
+  query?: DatasourceQuery,
+): Promise<DatasourceOption[]> {
+  const provider = datasources.get(name);
+  if (!provider) {
+    logger.warn(`Datasource not found: ${name}`);
+    return [];
+  }
+
+  try {
+    const options = await provider(query);
+    return limitOptions(
+      options.filter((option) => matchesQuery(option, query?.q)),
+      query?.limit,
+    );
+  } catch (error: any) {
+    logger.error(`Failed to fetch datasource ${name}: ${error.message}`);
+    return [];
+  }
+}
+
+export function listDatasources(): string[] {
+  return Array.from(datasources.keys());
+}
+
+function buildFriendAvatar(userId: string): string {
+  return `https://q1.qlogo.cn/g?b=qq&nk=${encodeURIComponent(userId)}&s=100`;
+}
+
+function buildGroupAvatar(groupId: string): string {
+  return `https://p.qlogo.cn/gh/${encodeURIComponent(groupId)}/${encodeURIComponent(groupId)}/100`;
+}
+
+function getConnectedBots(): any[] {
+  return Array.from(connectedBots.values()).filter(Boolean);
+}
+
+async function fetchFriendOptions(): Promise<DatasourceOption[]> {
+  const bots = getConnectedBots();
+  const merged = new Map<string, DatasourceOption>();
+
+  await Promise.all(
+    bots.map(async (bot) => {
+      const list = await bot.getFriendList().catch(() => []);
+      for (const item of Array.isArray(list) ? list : []) {
+        const userId = String(item?.user_id ?? "").trim();
+        if (!userId) {
+          continue;
+        }
+        const nickname = String(item?.nickname ?? "").trim();
+        const remark = String(item?.remark ?? "").trim();
+        const label = remark || nickname || userId;
+        merged.set(userId, {
+          value: userId,
+          label,
+          description: `QQ ${userId}${nickname && remark && nickname !== remark ? ` · ${nickname}` : ""}`,
+          meta: {
+            type: "qq_friend",
+            qq: userId,
+            nickname,
+            remark,
+            avatarUrl: buildFriendAvatar(userId),
+            searchText: [userId, nickname, remark].filter(Boolean).join(" "),
+          },
+        });
+      }
+    }),
+  );
+
+  return Array.from(merged.values()).sort((a, b) =>
+    a.label.localeCompare(b.label, "zh-Hans-CN"),
+  );
+}
+
+async function fetchGroupOptions(): Promise<DatasourceOption[]> {
+  const bots = getConnectedBots();
+  const merged = new Map<string, DatasourceOption>();
+
+  await Promise.all(
+    bots.map(async (bot) => {
+      const list = await bot.getGroupList().catch(() => []);
+      for (const item of Array.isArray(list) ? list : []) {
+        const groupId = String(item?.group_id ?? "").trim();
+        if (!groupId) {
+          continue;
+        }
+        const groupName = String(item?.group_name ?? "").trim() || groupId;
+        const memberCount = Number(item?.member_count);
+        merged.set(groupId, {
+          value: groupId,
+          label: groupName,
+          description: Number.isFinite(memberCount)
+            ? `${groupId} · ${memberCount} 人`
+            : `群号 ${groupId}`,
+          meta: {
+            type: "qq_group",
+            groupId,
+            groupName,
+            memberCount: Number.isFinite(memberCount) ? memberCount : undefined,
+            avatarUrl: buildGroupAvatar(groupId),
+            searchText: [groupId, groupName].filter(Boolean).join(" "),
+          },
+        });
+      }
+    }),
+  );
+
+  return Array.from(merged.values()).sort((a, b) =>
+    a.label.localeCompare(b.label, "zh-Hans-CN"),
+  );
+}
+
+// Built-in datasources
+export function initBuiltinDatasources(): void {
+  // QQ groups datasource
+  registerDatasource("qq_groups", async () => {
+    return fetchGroupOptions();
+  });
+
+  // QQ friends datasource
+  registerDatasource("qq_friends", async () => {
+    return fetchFriendOptions();
+  });
+}