mioku-plugin-chat 2.0.0

package/core/external-skills.ts

@@ -0,0 +1,94 @@
+import type { AISkill, SkillPermissionRole } from "mioku";
+import type { ChatConfig } from "../types";
+
+function normalizeSkillName(name: unknown): string {
+  return String(name || "").trim();
+}
+
+export function getAllowedExternalSkillNameSet(
+  config: ChatConfig,
+): Set<string> | null {
+  const entries = Array.isArray(config.allowedExternalSkills)
+    ? config.allowedExternalSkills
+        .map((item) => normalizeSkillName(item))
+        .filter(Boolean)
+    : [];
+
+  return entries.length > 0 ? new Set(entries) : null;
+}
+
+export function isExternalSkillAllowed(
+  config: ChatConfig,
+  skillName: string,
+): boolean {
+  const allowedSkillNames = getAllowedExternalSkillNameSet(config);
+  if (!allowedSkillNames) {
+    return true;
+  }
+
+  return allowedSkillNames.has(normalizeSkillName(skillName));
+}
+
+const SKILL_PERMISSION_RANK: Record<SkillPermissionRole, number> = {
+  member: 0,
+  admin: 1,
+  owner: 2,
+};
+
+export function normalizeSkillPermissionRole(
+  role: unknown,
+): SkillPermissionRole {
+  const normalized = String(role || "")
+    .trim()
+    .toLowerCase();
+  if (
+    normalized === "member" ||
+    normalized === "admin" ||
+    normalized === "owner"
+  ) {
+    return normalized;
+  }
+  return "member";
+}
+
+export function getSkillRequiredPermissionRole(
+  skill: AISkill | undefined,
+): SkillPermissionRole {
+  if (!skill) {
+    return "member";
+  }
+  return normalizeSkillPermissionRole(skill.permission);
+}
+
+export function hasSkillPermission(
+  triggerRole: SkillPermissionRole,
+  requiredRole: SkillPermissionRole,
+): boolean {
+  return (
+    SKILL_PERMISSION_RANK[triggerRole] >= SKILL_PERMISSION_RANK[requiredRole]
+  );
+}
+
+export function isSkillAllowedForRole(
+  skill: AISkill | undefined,
+  triggerRole: SkillPermissionRole,
+): boolean {
+  return hasSkillPermission(triggerRole, getSkillRequiredPermissionRole(skill));
+}
+
+export function filterAllowedExternalSkills(
+  config: ChatConfig,
+  skills: AISkill[],
+  triggerRole?: SkillPermissionRole,
+): AISkill[] {
+  const allowedSkillNames = getAllowedExternalSkillNameSet(config);
+  return skills.filter((skill) => {
+    if (
+      allowedSkillNames &&
+      !allowedSkillNames.has(normalizeSkillName(skill.name))
+    ) {
+      return false;
+    }
+    return !(triggerRole && !isSkillAllowedForRole(skill, triggerRole));
+  });
+}

package/core/feature-prompts.ts

@@ -0,0 +1,47 @@
+import type { ChatConfig } from "../types";
+
+export type FeatureName =
+  | "markdown"
+  | "audio"
+  | "web_search"
+  | "web_read_page"
+  | "recall_memory";
+
+export interface FeatureMeta {
+  name: FeatureName;
+  configKey: string;
+  hasTools: boolean;
+}
+
+export const FEATURE_METAS: FeatureMeta[] = [
+  {
+    name: "markdown",
+    configKey: "enableMarkdownScreenshot",
+    hasTools: false,
+  },
+  { name: "audio", configKey: "audio.enabled", hasTools: false },
+  { name: "web_search", configKey: "searxng.enabled", hasTools: true },
+  { name: "web_read_page", configKey: "webReader.enabled", hasTools: true },
+  { name: "recall_memory", configKey: "memory.enabled", hasTools: true },
+];
+
+export function isFeatureEnabled(
+  config: ChatConfig,
+  feature: FeatureMeta,
+): boolean {
+  const key = feature.configKey;
+  const parts = key.split(".");
+  let value: any = config;
+  for (const part of parts) {
+    value = value?.[part];
+  }
+  return Boolean(value);
+}
+
+export function isBuiltinFeature(name: string): name is FeatureName {
+  return FEATURE_METAS.some((f) => f.name === name);
+}
+
+export function getFeatureMeta(name: FeatureName): FeatureMeta | undefined {
+  return FEATURE_METAS.find((f) => f.name === name);
+}

package/core/media/audio.ts

@@ -0,0 +1,73 @@
+import type { AudioConfig } from "../../types";
+
+interface TTSResponse {
+  audio_base64?: string;
+  detail?: string;
+  error?: string;
+}
+
+function ensureTrailingSlash(value: string): string {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+function detectAudioLanguage(text: string): string {
+  if (/[\u3040-\u30ff]/.test(text)) {
+    return "all_ja";
+  }
+  if (/[\u4e00-\u9fff]/.test(text)) {
+    return "all_zh";
+  }
+  return "en";
+}
+
+export async function synthesizeAudioBase64(
+  config: AudioConfig,
+  text: string,
+): Promise<string> {
+  const trimmedText = String(text || "").trim();
+  if (!config.enabled) {
+    throw new Error("Audio output is disabled");
+  }
+  if (!trimmedText) {
+    throw new Error("Audio text cannot be empty");
+  }
+  if (!config.baseUrl?.trim()) {
+    throw new Error("Audio service baseUrl is not configured");
+  }
+
+  const endpoint = new URL("tts", ensureTrailingSlash(config.baseUrl.trim()));
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+
+  const apiKey = config.apiKey?.trim();
+  if (apiKey) {
+    headers["X-API-Key"] = apiKey;
+  }
+
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      text: trimmedText,
+      text_lang: detectAudioLanguage(trimmedText),
+    }),
+    signal: AbortSignal.timeout(Math.max(1000, config.timeoutMs || 20_000)),
+  });
+
+  const payload = (await response.json().catch(() => ({}))) as TTSResponse;
+  if (!response.ok) {
+    throw new Error(
+      payload?.detail ||
+        payload?.error ||
+        `TTS request failed with status ${response.status}`,
+    );
+  }
+
+  const audioBase64 = String(payload.audio_base64 || "").trim();
+  if (!audioBase64) {
+    throw new Error("TTS response missing audio_base64");
+  }
+
+  return `base64://${audioBase64}`;
+}

package/core/media/gif-extractor.ts

@@ -0,0 +1,118 @@
+import { logger } from "mioki";
+import sharp from "sharp";
+
+/**
+ * GIF 帧提取结果
+ */
+export interface GifFramesResult {
+  frames: string[]; // base64 编码的帧（PNG 格式）
+  buffer: Buffer; // 原始 GIF buffer
+}
+
+/**
+ * 从 GIF 提取三帧（第一帧、中间帧、末尾帧）
+ * @param gifUrl GIF 图片 URL
+ * @returns 三帧的 base64 编码和原始 buffer
+ */
+export async function extractGifFrames(
+  gifUrl: string,
+): Promise<GifFramesResult | null> {
+  try {
+    // 下载 GIF
+    const response = await fetch(gifUrl);
+    if (!response.ok) {
+      logger.error(
+        `[gif-extractor] Failed to fetch GIF: ${response.statusText}`,
+      );
+      return null;
+    }
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+
+    // 获取 GIF 元数据以确定总帧数
+    const metadata = await sharp(buffer, { animated: true }).metadata();
+    const totalPages = metadata.pages || 1;
+
+    if (totalPages === 1) {
+      // 只有一帧，提取第一帧
+      const frame = await sharp(buffer, { animated: false, page: 0 })
+        .png()
+        .toBuffer();
+      const base64 = `data:image/png;base64,${frame.toString("base64")}`;
+      return { frames: [base64], buffer };
+    }
+
+    // 计算要提取的帧索引
+    const firstIndex = 0;
+    const middleIndex = Math.floor(totalPages / 2);
+    const lastIndex = totalPages - 1;
+
+    const frames: string[] = [];
+
+    // 提取第一帧
+    const firstFrame = await sharp(buffer, {
+      animated: false,
+      page: firstIndex,
+    })
+      .png()
+      .toBuffer();
+    frames.push(`data:image/png;base64,${firstFrame.toString("base64")}`);
+
+    // 提取中间帧
+    if (middleIndex !== firstIndex && middleIndex !== lastIndex) {
+      const middleFrame = await sharp(buffer, {
+        animated: false,
+        page: middleIndex,
+      })
+        .png()
+        .toBuffer();
+      frames.push(`data:image/png;base64,${middleFrame.toString("base64")}`);
+    }
+
+    // 提取末尾帧
+    if (lastIndex !== firstIndex) {
+      const lastFrame = await sharp(buffer, {
+        animated: false,
+        page: lastIndex,
+      })
+        .png()
+        .toBuffer();
+      frames.push(`data:image/png;base64,${lastFrame.toString("base64")}`);
+    }
+
+    logger.info(
+      `[gif-extractor] Extracted ${frames.length} frames from GIF (${totalPages} total)`,
+    );
+    return { frames, buffer };
+  } catch (err) {
+    logger.error(`[gif-extractor] Failed to extract frames: ${err}`);
+    return null;
+  }
+}
+
+/**
+ * 检查 URL 是否为 GIF
+ * 优先检查 URL 后缀，其次检测文件内容
+ */
+export async function isGifUrl(url: string): Promise<boolean> {
+  if (url.toLowerCase().includes(".gif")) {
+    return true;
+  }
+
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        Referer: "https://qq.com/",
+      },
+    });
+    const contentType = response.headers.get("content-type");
+    if (contentType && contentType.includes("image/gif")) {
+      return true;
+    }
+  } catch {}
+
+  return false;
+}