mioku-service-webui 4.7.0 → 4.8.1

package/auth.ts

@@ -1,4 +1,5 @@
 import * as crypto from "node:crypto";
+import { logger } from "mioku";
 import type { Context, Next } from "hono";
 import type { AuthConfig } from "./types";
 import { AUTH_PATH, WEEK_MS, readJsonFile, writeJsonFile } from "./utils";
@@ -27,13 +28,79 @@ export function ensureAuthConfig(): AuthConfig {
     void notifyOwnersAuthTokenRefreshed(
       generated.token,
       generated.expiresAt,
-    ).catch(() => {});
+    ).catch((err) => {
+      logger.warn(
+        `[webui] 通知主人密钥更新失败: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    });
     return generated;
   }
 
   return existing;
 }
 
+/**
+ * 距密钥过期多久时主动刷新（默认 6 小时）。
+ * 提前刷新的好处：即便长时间没有 API 请求 / 登录触发，密钥也会轮换并通知主人。
+ */
+const AUTH_REFRESH_LEAD_MS = 6 * 60 * 60 * 1000;
+/** 定时巡检周期（默认 60 秒）。 */
+const AUTH_REFRESH_INTERVAL_MS = 60 * 1000;
+
+let authRefreshTimer: NodeJS.Timeout | null = null;
+
+/**
+ * 启动密钥定时巡检。即使没有前端访问 / 没有登录请求，
+ * 也会在密钥接近过期时主动刷新并通知主人。
+ */
+export function startAuthRefreshTimer(): void {
+  if (authRefreshTimer) {
+    return;
+  }
+  // 启动时立即巡检一次，处理"服务运行时密钥刚好过期"的场景
+  try {
+    ensureAuthConfig();
+  } catch (err) {
+    logger.warn(
+      `[webui] 启动时巡检密钥失败: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+  authRefreshTimer = setInterval(() => {
+    try {
+      const now = Date.now();
+      const existing = readJsonFile<AuthConfig | null>(AUTH_PATH, null);
+      // 仅在接近过期 / 已过期时才触发刷新逻辑，避免无意义的写文件
+      if (
+        existing &&
+        existing.token &&
+        existing.expiresAt &&
+        existing.expiresAt - now > AUTH_REFRESH_LEAD_MS
+      ) {
+        return;
+      }
+      ensureAuthConfig();
+    } catch (err) {
+      logger.warn(
+        `[webui] 定时巡检密钥失败: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }, AUTH_REFRESH_INTERVAL_MS);
+  // unref 避免阻塞进程退出
+  if (typeof authRefreshTimer.unref === "function") {
+    authRefreshTimer.unref();
+  }
+  logger.info(
+    `[webui] 已启动密钥定时巡检（周期 ${AUTH_REFRESH_INTERVAL_MS / 1000}s，提前 ${AUTH_REFRESH_LEAD_MS / 60 / 60 / 1000}h 刷新）`,
+  );
+}
+
+export function stopAuthRefreshTimer(): void {
+  if (authRefreshTimer) {
+    clearInterval(authRefreshTimer);
+    authRefreshTimer = null;
+  }
+}
+
 export function verifyAuthHeader(c: Context): boolean {
   const auth = c.req.header("authorization") || "";
   const token = auth.replace(/^Bearer\s+/i, "").trim();

package/config-page-loader.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import matter from "gray-matter";
-import { logger } from "mioki";
+import { logger } from "mioku";
 
 export interface ConfigField {
   key: string;
@@ -44,6 +44,14 @@ export function loadServiceConfigPage(serviceName: string): ConfigPageManifest |
   return loadConfigPage(serviceName, possiblePaths);
 }
 
+export function loadAdapterConfigPage(adapterName: string): ConfigPageManifest | null {
+  const possiblePaths = [
+    path.join(process.cwd(), "node_modules", `mioku-adapter-${adapterName}`),
+  ];
+
+  return loadConfigPage(adapterName, possiblePaths);
+}
+
 function loadConfigPage(
   packageName: string,
   possiblePaths: string[],

package/datasources.ts

@@ -1,4 +1,4 @@
-import { connectedBots, logger } from "mioki";
+import { connectedBots, logger } from "mioku";
 
 export interface DatasourceOption {
   value: string;

package/index.ts

@@ -1,13 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { logger } from "mioki";
+import { logger } from "mioku";
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { createNodeWebSocket } from "@hono/node-ws";
 import type { MiokuService } from "mioku";
 import type { WebUISettings } from "./types";
-import { ensureAuthConfig, loginWithToken, requireAuth } from "./auth";
+import {
+  ensureAuthConfig,
+  loginWithToken,
+  requireAuth,
+  startAuthRefreshTimer,
+  stopAuthRefreshTimer,
+} from "./auth";
 import {
   ensureWebUIDist,
   getWebUISettings,
@@ -23,6 +29,7 @@ import {
   createDBRoutes,
   createPluginConfigRoutes,
   createServiceConfigRoutes,
+  createAdapterConfigRoutes,
   createMemeRoutes,
   createManageRoutes,
   createStoreRoutes,
@@ -118,6 +125,7 @@ class WebUIRuntime {
     this.app.route("/api/db", createDBRoutes());
     this.app.route("/api/plugin-config", createPluginConfigRoutes());
     this.app.route("/api/service-config", createServiceConfigRoutes());
+    this.app.route("/api/adapter-config", createAdapterConfigRoutes());
     this.app.route("/api/meme", createMemeRoutes());
     this.app.route("/api/data-management", createDataManagementRoutes());
     this.app.route("/api/stranger", createStrangerRoutes());
@@ -239,8 +247,6 @@ const runtime = new WebUIRuntime();
 
 const webUIService: MiokuService = {
   name: "webui",
-  version: "4.2.0",
-  description: "Mioku WebUI 管理服务",
   api: {
     getSettings: () => getWebUISettings(),
   } as WebUIServiceAPI,
@@ -250,9 +256,13 @@ const webUIService: MiokuService = {
     ensureAuthConfig();
     await ensureWebUIDist();
     await runtime.initRoutes();
+    // 启动密钥定时巡检：即便长时间没有前端访问 / 登录请求，
+    // 也会在密钥接近过期时主动刷新并通知主人。
+    startAuthRefreshTimer();
   },
 
   async dispose() {
+    stopAuthRefreshTimer();
     runtime.stop();
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-service-webui",
-  "version": "4.7.0",
+  "version": "4.8.1",
   "description": "Mioku WebUI 服务",
   "main": "index.ts",
   "type": "module",
@@ -22,15 +22,14 @@
     "adm-zip": "^0.5.16",
     "fflate": "^0.8.2",
     "gray-matter": "^4.0.3",
-    "hono": "4.12.14"
+    "hono": "4.12.14",
+    "systeminformation": "^5.31.6"
   },
   "peerDependencies": {
-    "mioku-service-ai": "^0.2.0",
-    "mioki": "^0.16.0"
+    "mioku-service-ai": "^4.0.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",
-    "mioki": "^0.16.0",
     "mioku": "workspace:*",
     "mioku-service-ai": "workspace:*"
   }

package/port-utils.ts

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { logger } from "mioki";
+import { logger } from "mioku";
 
 const execFileAsync = promisify(execFile);
 

package/routes/access-control.ts

@@ -1,12 +1,12 @@
 import { Hono } from "hono";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { logger } from "mioki";
-import { readJsonFile, writeJsonFile, NODE_MODULES_DIR } from "../utils";
+import { getActiveCommandManager, logger } from "mioku";
+import { isPackageDir, readJsonFile, writeJsonFile, NODE_MODULES_DIR } from "../utils";
 
 const ACCESS_CONFIG_PATH = path.resolve(
   process.cwd(),
-  "config/boot/access-control.json",
+  "config/core/access-control.json",
 );
 
 const DEFAULT_CONFIG = {
@@ -38,24 +38,37 @@ interface AccessItem {
   desc?: string;
   match?: string;
   event?: string;
+  permission?: string;
+  priority?: number;
   fromHook: boolean;
 }
 
 function readAccessCatalog(): AccessItem[] {
+  const manager = getActiveCommandManager();
+  if (manager) {
+    return manager.catalog().map((item) => ({
+      kind: item.kind,
+      plugin: item.plugin,
+      id: item.id,
+      label: item.label,
+      desc: item.desc,
+      match: item.match,
+      event: item.event,
+      permission: item.permission,
+      priority: item.priority,
+      fromHook:
+        item.source === "manifest" && Boolean(item.match || item.event),
+    }));
+  }
   if (!fs.existsSync(NODE_MODULES_DIR)) return [];
   const entries = fs.readdirSync(NODE_MODULES_DIR, { withFileTypes: true });
   const items: AccessItem[] = [];
 
   for (const entry of entries) {
-    if (!entry.name.startsWith("mioku-plugin-")) continue;
+    if (!entry.name.toLowerCase().startsWith("mioku-plugin-")) continue;
     const fullPath = path.join(NODE_MODULES_DIR, entry.name);
-    let stat: fs.Stats;
-    try {
-      stat = fs.lstatSync(fullPath);
-    } catch {
-      continue;
-    }
-    if (!stat.isDirectory() && !stat.isSymbolicLink()) continue;
+    // Windows 上 pnpm/bun workspace 会用 NTFS junction，旧 lstat 检查会误判
+    if (!isPackageDir(fullPath)) continue;
 
     const pkgPath = path.join(fullPath, "package.json");
     if (!fs.existsSync(pkgPath)) continue;
@@ -66,7 +79,7 @@ function readAccessCatalog(): AccessItem[] {
       continue;
     }
 
-    const name = entry.name.replace(/^mioku-plugin-/, "");
+    const name = entry.name.replace(/^mioku-plugin-/i, "");
     const mioku = pkg.mioku || {};
     const help = mioku.help || { title: name, description: "", commands: [] };
     const hooks: Array<{ id: string; match?: string; event?: string; description?: string }> =

package/routes/adapter-config.ts

@@ -0,0 +1,85 @@
+import { Hono } from "hono";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadAdapterConfigPage } from "../config-page-loader";
+import { getAdapterConfigs, updateAdapterConfig } from "../system";
+import { isPackageDir } from "../utils";
+
+function listAdaptersFromNodeModules(): string[] {
+  const modulesPath = path.join(process.cwd(), "node_modules");
+  const adapters: string[] = [];
+  if (!fs.existsSync(modulesPath)) return adapters;
+
+  let entries: import("fs").Dirent[];
+  try {
+    entries = fs.readdirSync(modulesPath, { withFileTypes: true });
+  } catch {
+    return adapters;
+  }
+
+  for (const entry of entries) {
+    if (!entry.name.toLowerCase().startsWith("mioku-adapter-")) continue;
+    const fullPath = path.join(modulesPath, entry.name);
+    if (!isPackageDir(fullPath)) continue;
+    adapters.push(entry.name.replace(/^mioku-adapter-/i, ""));
+  }
+  return adapters.sort((a, b) => a.localeCompare(b));
+}
+
+export function createAdapterConfigRoutes() {
+  const app = new Hono();
+
+  app.get("/overview", (c) => {
+    const adapters = listAdaptersFromNodeModules();
+    const overview = adapters
+      .map((name) => {
+        const manifest = loadAdapterConfigPage(name);
+        return {
+          name,
+          title: manifest?.title || name,
+          description: manifest?.description,
+          hasPage: manifest?.hasCustomPage || false,
+        };
+      })
+      .filter((a) => a.hasPage);
+
+    return c.json({ ok: true, data: overview });
+  });
+
+  app.get("/:name/page", (c) => {
+    const name = c.req.param("name");
+    const manifest = loadAdapterConfigPage(name);
+    if (!manifest) {
+      return c.json({ ok: true, data: null });
+    }
+
+    return c.json({
+      ok: true,
+      data: {
+        plugin: manifest.plugin,
+        title: manifest.title,
+        description: manifest.description,
+        markdown: manifest.markdown,
+        fields: manifest.fields,
+        hasCustomPage: manifest.hasCustomPage,
+        configs: {
+          [name]: getAdapterConfigs(name),
+        },
+      },
+    });
+  });
+
+  app.get("/:name", (c) => {
+    const name = c.req.param("name");
+    return c.json({ ok: true, data: getAdapterConfigs(name) });
+  });
+
+  app.put("/:name", async (c) => {
+    const name = c.req.param("name");
+    const body = await c.req.json();
+    const data = updateAdapterConfig(name, body);
+    return c.json({ ok: true, data });
+  });
+
+  return app;
+}

package/routes/ai.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { logger } from "mioki";
+import { logger } from "mioku";
 import { getChatConfig, updateChatConfig } from "../system";
 import { listStickerCatalog } from "../database";
 import aiService from "mioku-service-ai";
@@ -332,18 +332,42 @@ export function createAIRoutes() {
       modelId: body?.modelId,
       name: body?.name,
       capabilities: body?.capabilities,
+      thinkingLevel: body?.thinkingLevel,
     });
     return c.json({ ok: true, data: model });
   });
 
+  app.put("/models/:id", async (c) => {
+    const api = getAIApi();
+    if (!api?.setModelThinkingLevel) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = decodeURIComponent(c.req.param("id"));
+    const body = await c.req.json();
+    const rawLevel = body?.thinkingLevel;
+    const level =
+      rawLevel === null || rawLevel === undefined || rawLevel === ""
+        ? undefined
+        : String(rawLevel);
+    logger.info(`[webui-action] ai.model.thinking.update`, {
+      id,
+      level: level ?? "(default)",
+    });
+    const ok = api.setModelThinkingLevel(id, level as any);
+    return c.json({ ok });
+  });
+
   app.delete("/models/:id", (c) => {
     const api = getAIApi();
-    if (!api?.removeCustomModel) {
+    if (!api?.removeModel && !api?.removeCustomModel) {
       return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
     }
     const id = decodeURIComponent(c.req.param("id"));
     logger.info(`[webui-action] ai.model.remove`, { id });
-    return c.json({ ok: Boolean(api.removeCustomModel(id)) });
+    const ok = api.removeModel
+      ? Boolean(api.removeModel(id))
+      : Boolean(api.removeCustomModel(id));
+    return c.json({ ok });
   });
 
   app.get("/roles", (c) => {

package/routes/config.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { logger } from "mioki";
+import { logger } from "mioku";
 import {
   getMiokuConfig,
   updateMiokuConfig,
@@ -25,7 +25,7 @@ export function createConfigRoutes() {
       admins: body?.admins?.length,
       napcat: body?.napcat?.length,
       plugins: body?.plugins?.length,
-      bootConfigured: Boolean(body?.boot),
+      coreConfigured: Boolean(body?.core),
     });
     const data = updateMiokuConfig(body);
     return c.json({ ok: true, data });

package/routes/data-management.ts

@@ -569,7 +569,7 @@ export function createDataManagementRoutes() {
 
     const file = await fs.promises.readFile(filePath);
     c.header("content-type", "application/zip");
-    c.header("content-disposition", `attachment; filename="${path.basename(filePath)}"`);
+    c.header("content-disposition", `attachment); filename="${path.basename(filePath)}"`);
     return c.body(file);
   });
 

package/routes/index.ts

@@ -2,6 +2,7 @@ export { createConfigRoutes } from "./config";
 export { createWebUISettingsRoutes } from "./webui";
 export { createAIRoutes } from "./ai";
 export { createDBRoutes, createPluginConfigRoutes, createMemeRoutes, createServiceConfigRoutes } from "./db";
+export { createAdapterConfigRoutes } from "./adapter-config";
 export { createManageRoutes } from "./manage";
 export { createStoreRoutes } from "./store";
 export { createDataManagementRoutes } from "./data-management";

package/routes/manage.ts

@@ -27,6 +27,9 @@ export function createManageRoutes() {
   app.get("/services", (c) =>
     c.json({ ok: true, data: listManagedPackages("service") }),
   );
+  app.get("/adapters", (c) =>
+    c.json({ ok: true, data: listManagedPackages("adapter") }),
+  );
   app.get("/plugins/overview", async (c) =>
     c.json({ ok: true, data: await listManagedPackagesWithUpdates("plugin") }),
   );
@@ -43,6 +46,14 @@ export function createManageRoutes() {
     const result = await getManagedPackageDetail(name, "service");
     return c.json(result);
   });
+  app.get("/adapters/overview", async (c) =>
+    c.json({ ok: true, data: await listManagedPackagesWithUpdates("adapter") }),
+  );
+  app.get("/adapters/:name", async (c) => {
+    const name = c.req.param("name");
+    const result = await getManagedPackageDetail(name, "adapter");
+    return c.json(result);
+  });
 
   app.post("/install", async (c) => {
     const body = (await c.req.json()) as InstallRequest;
@@ -53,7 +64,7 @@ export function createManageRoutes() {
   app.post("/check-update", async (c) => {
     const body = (await c.req.json()) as {
       name: string;
-      target: "plugin" | "service";
+      target: "plugin" | "service" | "adapter";
     };
     const result = await checkUpdate(body.name, body.target);
     return c.json(result);
@@ -82,7 +93,7 @@ export function createManageRoutes() {
     const body = (await c.req.json()) as Partial<ChangeRepoRequest>;
     const result = await changeManagedPackageRepo(
       String(body.name || ""),
-      (body.target || "plugin") as "plugin" | "service",
+      (body.target || "plugin") as "plugin" | "service" | "adapter",
       String(body.repoUrl || ""),
     );
     return c.json(result);

package/routes/store.ts

@@ -19,6 +19,7 @@ interface OfficialServiceEntry {
 interface OfficialRegistry {
   plugins?: Record<string, OfficialPluginEntry>;
   services?: Record<string, OfficialServiceEntry>;
+  adapters?: Record<string, OfficialPluginEntry>;
 }
 
 let cachedOfficialRegistry: OfficialRegistry | null = null;
@@ -56,9 +57,11 @@ async function readOfficialRegistry(force = false): Promise<OfficialRegistry> {
 function buildOfficialMaps(registry: OfficialRegistry): {
   plugins: Map<string, OfficialPluginEntry>;
   services: Map<string, OfficialServiceEntry>;
+  adapters: Map<string, OfficialPluginEntry>;
 } {
   const plugins = new Map<string, OfficialPluginEntry>();
   const services = new Map<string, OfficialServiceEntry>();
+  const adapters = new Map<string, OfficialPluginEntry>();
 
   for (const [, entry] of Object.entries(registry.plugins || {})) {
     if (entry?.npm) {
@@ -72,21 +75,25 @@ function buildOfficialMaps(registry: OfficialRegistry): {
     }
   }
 
-  return { plugins, services };
-}
+  for (const [, entry] of Object.entries(registry.adapters || {})) {
+    if (entry?.npm) {
+      adapters.set(entry.npm, entry);
+    }
+  }
 
-function isServicePackage(name: string): boolean {
-  return name.startsWith("mioku-service-");
+  return { plugins, services, adapters };
 }
 
-function inferTypeFromPackageName(name: string): "plugin" | "service" | null {
+function inferTypeFromPackageName(name: string): "plugin" | "service" | "adapter" | null {
   if (name.startsWith("mioku-plugin-")) return "plugin";
   if (name.startsWith("mioku-service-")) return "service";
+  if (name.startsWith("mioku-adapter-")) return "adapter";
   return null;
 }
 
-function inferDisplayName(packageName: string, type: "plugin" | "service"): string {
-  const prefix = type === "plugin" ? "mioku-plugin-" : "mioku-service-";
+function inferDisplayName(packageName: string, type: "plugin" | "service" | "adapter"): string {
+  const prefix =
+    type === "plugin" ? "mioku-plugin-" : type === "service" ? "mioku-service-" : "mioku-adapter-";
   return packageName.startsWith(prefix)
     ? packageName.slice(prefix.length)
     : packageName;
@@ -189,7 +196,9 @@ export function createStoreRoutes() {
       const officialEntry =
         type === "plugin"
           ? officialMaps.plugins.get(packageName)
-          : officialMaps.services.get(packageName);
+          : type === "service"
+            ? officialMaps.services.get(packageName)
+            : officialMaps.adapters.get(packageName);
       const repositoryUrl = normalizeRepositoryUrl(latest?.repository);
 
       return c.json({
@@ -213,11 +222,13 @@ export function createStoreRoutes() {
           requiredServices: Array.isArray(latest?.mioku?.services)
             ? latest.mioku.services
             : [],
-          installTarget: isServicePackage(packageName) ? "service" : "plugin",
+          installTarget: type,
           installPath:
             type === "plugin"
               ? `plugins/${inferDisplayName(packageName, "plugin")}`
-              : getServiceInstallPath(latest, packageName),
+              : type === "service"
+                ? getServiceInstallPath(latest, packageName)
+                : `adapters/${inferDisplayName(packageName, "adapter")}`,
         },
       });
     } catch (error: any) {

package/routes/stranger.ts

@@ -1,5 +1,7 @@
 import { Hono } from "hono";
-import { connectedBots, logger } from "mioki";
+import type { Bot } from "mioku";
+import {connectedBots,
+  logger} from "mioku";
 
 interface StrangerInfoResponse {
   ok: boolean;
@@ -18,7 +20,7 @@ const FETCH_TIMEOUT_MS = 4000;
 const nicknameCache = new Map<string, CacheEntry>();
 const inflight = new Map<string, Promise<string | null>>();
 
-function getConnectedBots(): any[] {
+function getConnectedBots(): Bot[] {
   return Array.from(connectedBots.values()).filter(Boolean);
 }
 
@@ -48,23 +50,20 @@ function setCached(userId: string, nickname: string | null): void {
 }
 
 async function fetchNicknameFromBot(
-  bot: any,
+  bot: Bot,
   userId: string,
 ): Promise<string | null> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
-    const res = await bot.api("get_stranger_info", { user_id: userId });
-    const data = res?.data || res;
-    const nickname = String(data?.nickname ?? "").trim();
+    const info = await bot.getFriendInfo(userId);
+    const nickname = String(info?.nickname ?? "").trim();
     return nickname || null;
-  } catch (error: any) {
+  } catch (error) {
     logger.warn(
-      `stranger-info: bot ${bot?.uin || bot?.bot_id || "?"} 查询 ${userId} 失败: ${error?.message || error}`,
+      `stranger-info: bot ${bot.bot_id} 查询 ${userId} 失败: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
     );
     return null;
-  } finally {
-    clearTimeout(timer);
   }
 }
 
@@ -77,9 +76,7 @@ async function lookupNickname(userId: string): Promise<string | null> {
 
   const promise = (async () => {
     const bots = getConnectedBots();
-    if (bots.length === 0) {
-      return null;
-    }
+    if (bots.length === 0) return null;
     const results = await Promise.all(
       bots.map((bot) => fetchNicknameFromBot(bot, userId)),
     );
@@ -105,7 +102,7 @@ export function createStrangerRoutes() {
   const app = new Hono();
 
   app.post("/info", async (c) => {
-    const body = await c.req.json().catch(() => ({}));
+    const body = (await c.req.json().catch(() => ({}))) as { user_id?: unknown };
     const userId = normalizeUserId(body?.user_id);
     if (!isValidQQNumber(userId)) {
       return c.json(
@@ -129,8 +126,10 @@ export function createStrangerRoutes() {
         ok: true,
         data: { userId, nickname },
       } satisfies StrangerInfoResponse);
-    } catch (error: any) {
-      logger.error(`stranger-info 失败: ${error?.message || error}`);
+    } catch (error) {
+      logger.error(
+        `stranger-info 失败: ${error instanceof Error ? error.message : String(error)}`,
+      );
       return c.json(
         {
           ok: false,