koishi-plugin-vox 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+import { Context, Schema } from 'koishi';
+import SilkService from 'koishi-plugin-silk';
+declare module 'koishi' {
+    interface Context {
+        silk: SilkService;
+    }
+}
+export declare const name = "vox";
+export declare const usage = "\u8DEF\u5F84\u4E0B\u7684\u6587\u4EF6\u5939\u5C06\u4F1A\u88AB\u8BA4\u4E3A\u4E00\u4E2A\u97F3\u8272\uFF0C\u5B50\u6587\u4EF6\u5939\u5185\u6240\u6709\u97F3\u9891\u5C06\u4F1A\u8BFB\u53D6\u4E3A\u53EF\u7528\u97F3\u9891\uFF0C\u6587\u4EF6\u540D\uFF08\u4E0D\u542B\u6269\u5C55\u540D\uFF09\u5373\u4E3A\u89E6\u53D1\u540D\u79F0\u3002";
+export declare const inject: {
+    optional: string[];
+};
+export interface Config {
+    soundPath: string[];
+    audioType: "mp3" | "silk";
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,229 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name,
+  usage: () => usage
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_child_process = require("child_process");
+var name = "vox";
+var usage = "路径下的文件夹将会被认为一个音色，子文件夹内所有音频将会读取为可用音频，文件名（不含扩展名）即为触发名称。";
+var inject = {
+  optional: ["silk"]
+};
+var Config = import_koishi.Schema.object({
+  soundPath: import_koishi.Schema.array(import_koishi.Schema.string()).description("用于搜索音频的*绝对*路径，支持搜索mp3 wav ogg flac m4a aac格式"),
+  audioType: import_koishi.Schema.union(["mp3", "silk"]).default("mp3").description("最终发送的类型，QQ及微信选择SILK")
+}).description("Vox");
+var AUDIO_EXTENSIONS = [".mp3", ".wav", ".ogg", ".flac", ".m4a", ".aac"];
+var voicePath = /* @__PURE__ */ new Map();
+async function buildVoicePath(soundPaths) {
+  voicePath.clear();
+  for (const basePath of soundPaths) {
+    try {
+      const entries = await (0, import_promises.readdir)(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const voiceName = entry.name;
+        const voiceDir = (0, import_path.join)(basePath, voiceName);
+        const audioMap = /* @__PURE__ */ new Map();
+        try {
+          const files = await (0, import_promises.readdir)(voiceDir, { withFileTypes: true });
+          for (const file of files) {
+            if (!file.isFile())
+              continue;
+            const ext = (0, import_path.extname)(file.name).toLowerCase();
+            if (!AUDIO_EXTENSIONS.includes(ext))
+              continue;
+            const triggerName = file.name.slice(0, -ext.length);
+            const fullPath = (0, import_path.join)(voiceDir, file.name);
+            audioMap.set(triggerName, fullPath);
+          }
+          if (audioMap.size > 0) {
+            voicePath.set(voiceName, audioMap);
+          }
+        } catch (err) {
+          continue;
+        }
+      }
+    } catch (err) {
+      continue;
+    }
+  }
+}
+__name(buildVoicePath, "buildVoicePath");
+var ffmpegAvailable = null;
+var ffmpegCheckPromise = null;
+async function checkFFmpeg() {
+  if (ffmpegAvailable !== null)
+    return ffmpegAvailable;
+  if (ffmpegCheckPromise)
+    return ffmpegCheckPromise;
+  ffmpegCheckPromise = new Promise((resolve) => {
+    const { spawn: spawn2 } = require("child_process");
+    let resolved = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve(false);
+      }
+    }, 3e3);
+    try {
+      const ffmpeg = spawn2("ffmpeg", ["-version"]);
+      ffmpeg.on("error", () => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          resolve(false);
+        }
+      });
+      ffmpeg.on("close", (code) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          resolve(code === 0);
+        }
+      });
+    } catch {
+      clearTimeout(timeout);
+      resolve(false);
+    }
+  }).then((result) => {
+    ffmpegAvailable = result;
+    return result;
+  });
+  return ffmpegCheckPromise;
+}
+__name(checkFFmpeg, "checkFFmpeg");
+async function runFFmpeg(commandArgs, ctx) {
+  return new Promise((resolve, reject) => {
+    const ffmpeg = (0, import_child_process.spawn)("ffmpeg", commandArgs);
+    const chunks = [];
+    const stderrChunks = [];
+    ffmpeg.stdout.on("data", (chunk) => chunks.push(chunk));
+    ffmpeg.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    ffmpeg.on("close", (code) => {
+      if (code === 0) {
+        resolve(Buffer.concat(chunks));
+      } else {
+        const stderrOutput = Buffer.concat(stderrChunks).toString("utf8").trim();
+        ctx.logger.error("FFmpeg stderr output:", stderrOutput);
+        reject(new Error(`FFmpeg exited with code ${code}`));
+      }
+    });
+    ffmpeg.on("error", reject);
+  });
+}
+__name(runFFmpeg, "runFFmpeg");
+async function concatSound(ctx, input, audioType) {
+  let args = [];
+  for (const inputPath of input) {
+    args.push("-i", inputPath);
+  }
+  args.push("-filter_complex");
+  const inputCount = input.length;
+  let filterChain = "";
+  for (let i = 0; i < inputCount; i++) {
+    filterChain += `[${i}:0]`;
+  }
+  filterChain += `concat=n=${inputCount}:v=0:a=1[out]`;
+  args.push(filterChain);
+  args.push("-map", "[out]");
+  if (audioType === "silk") {
+    args.push("-ar", "24000", "-ac", "1", "-f", "s16le", "pipe:1");
+    const data = await runFFmpeg(args, ctx);
+    return { data, mimeType: "audio/pcm" };
+  } else {
+    args.push("-f", "mp3", "pipe:1");
+    const data = await runFFmpeg(args, ctx);
+    return { data, mimeType: "audio/mp3" };
+  }
+}
+__name(concatSound, "concatSound");
+function apply(ctx, config) {
+  buildVoicePath(config.soundPath).then(() => {
+    ctx.logger.debug(`Loaded ${voicePath.size} voices: ${Array.from(voicePath.keys()).join(", ")}`);
+  }).catch((err) => {
+    ctx.logger.error("Failed to build voice path:", err);
+  });
+  checkFFmpeg().then((available) => {
+    if (!available) {
+      ctx.logger.warn("FFmpeg not found! Audio processing will fail.");
+    } else {
+      ctx.logger.debug("FFmpeg is available.");
+    }
+  });
+  ctx.command("vox <voice:string> <...rest:string> 合成一个vox").action(async ({ session }, voice, ...rest) => {
+    if (!voice) {
+      return "至少给个音色吧, 可用的音色有: " + Array.from(voicePath.keys()).join(", ");
+    }
+    const voiceMap = voicePath.get(voice);
+    if (!voiceMap) {
+      return `音色 ${voice} 不存在，可用的音色有: ${Array.from(voicePath.keys()).join(", ")}`;
+    }
+    if (!rest || rest.length === 0) {
+      return `至少给点东西拼接吧！`;
+    }
+    const audioPaths = [];
+    for (const trigger of rest) {
+      const path = voiceMap.get(trigger);
+      if (path) {
+        audioPaths.push(path);
+      }
+    }
+    if (audioPaths.length === 0) {
+      return `未找到任何音频！`;
+    }
+    try {
+      const { data, mimeType } = await concatSound(ctx, audioPaths, config.audioType);
+      if (config.audioType === "silk") {
+        if (ctx.silk) {
+          const silkResult = await ctx.silk.encode(data, 24e3);
+          await session.send(import_koishi.h.audio(silkResult.data, "audio/silk"));
+        } else {
+          return "没有安装必要的SILK插件";
+        }
+      } else {
+        await session.send(import_koishi.h.audio(data, mimeType));
+      }
+    } catch (error) {
+      ctx.logger.error("拼接音频失败:", error);
+      return "拼接音频失败";
+    }
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name,
+  usage
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "koishi-plugin-vox",
+  "description": "Vox合成器，依赖FFmpeg进行音频处理。",
+  "contributors": [
+    "Dr.Abc <me@drabc.net>"
+  ],
+  "version": "0.0.1",
+  "homepage": "https://github.com/DrAbcOfficial/koishi-plugin-vox",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DrAbcOfficial/koishi-plugin-vox.git"
+  },
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "devDependencies": {},
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  },
+  "koishi": {
+    "description": {
+      "en": "A Vox synthesizer relies on FFmpeg for audio processing.",
+      "zh": "Vox合成器，依赖FFmpeg进行音频处理。"
+    },
+    "service":{
+      "optional": ["silk"]
+    },
+    "preview": false
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-vox
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-vox?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-vox)
+
+Vox合成器