koishi-plugin-audiomeme 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "audiomeme";
+export declare const inject: {
+    optional: string[];
+};
+declare module 'koishi' {
+    interface Context {
+        puppeteer: import('koishi-plugin-puppeteer').default;
+        ffmpeg: any;
+        silk: any;
+    }
+}
+export interface Config {
+    cachePath: string;
+    cleanupInterval: number;
+    cacheMaxAge: number;
+    debug?: boolean;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.inject = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+const axios_1 = __importDefault(require("axios"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+exports.name = 'audiomeme';
+exports.inject = {
+    optional: ['puppeteer', 'ffmpeg', 'silk'],
+};
+exports.Config = koishi_1.Schema.object({
+    cachePath: koishi_1.Schema.string().default('cache/audiomeme').description('Cache directory for audio files.'),
+    cleanupInterval: koishi_1.Schema.number().default(10 * 60 * 1000).description('Cleanup interval in milliseconds (default 10 minutes).'),
+    cacheMaxAge: koishi_1.Schema.number().default(60 * 60 * 1000).description('Maximum age for cached files in milliseconds (default 1 hour).'),
+    debug: koishi_1.Schema.boolean().default(false).description('Enable debug mode to show more logs.'),
+});
+function apply(ctx, config) {
+    const logger = ctx.logger('audiomeme');
+    const sounds = require('../meme_sounds.json');
+    const lastAccess = new Map();
+    const cacheDir = path_1.default.resolve(ctx.baseDir, config.cachePath);
+    fs_extra_1.default.ensureDirSync(cacheDir);
+    async function playSound(name) {
+        const sound = sounds.find(s => s.name === name);
+        if (!sound)
+            return 'Meme sound not found.';
+        const fileName = `${encodeURIComponent(sound.name)}.mp3`;
+        const filePath = path_1.default.join(cacheDir, fileName);
+        if (config.debug)
+            logger.info(`Playing sound: ${name}, Path: ${filePath}`);
+        try {
+            if (!await fs_extra_1.default.pathExists(filePath)) {
+                if (config.debug)
+                    logger.info(`Cache miss. Downloading ${sound.name} from ${sound.url}`);
+                const response = await axios_1.default.get(sound.url, {
+                    responseType: 'arraybuffer',
+                    timeout: 10000,
+                    headers: {
+                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+                    }
+                });
+                if (response.data.byteLength === 0) {
+                    logger.error(`Downloaded file for ${name} is empty.`);
+                    return 'Downloaded file is empty.';
+                }
+                await fs_extra_1.default.writeFile(filePath, Buffer.from(response.data));
+                if (config.debug)
+                    logger.info(`Saved to ${filePath}, size: ${response.data.byteLength} bytes`);
+            }
+            else {
+                if (config.debug)
+                    logger.info(`Cache hit for ${name}.`);
+            }
+            lastAccess.set(fileName, Date.now());
+            const buffer = await fs_extra_1.default.readFile(filePath);
+            if (config.debug)
+                logger.info(`Sending audio as Buffer, size: ${buffer.byteLength} bytes`);
+            return koishi_1.h.audio(buffer, 'audio/mpeg');
+        }
+        catch (e) {
+            const error = e;
+            logger.error(`Failed to handle meme audio: ${error.message}`);
+            if (axios_1.default.isAxiosError(e)) {
+                return `Failed to download audio: ${e.code || e.message}`;
+            }
+            return 'Failed to download or play meme sound.';
+        }
+    }
+    ctx.command('memeaudio [name:string]', 'Play a meme sound')
+        .option('list', '-l List all available meme sounds', { type: 'boolean' })
+        .action(async ({ session, options }, name) => {
+        if (options?.list) {
+            if (!ctx.puppeteer)
+                return 'Puppeteer service not found.';
+            const listHtml = `
+          <html>
+            <head>
+              <style>
+                body {
+                  background-color: #1a1a1a;
+                  color: #ffffff;
+                  font-family: sans-serif;
+                  padding: 20px;
+                  margin: 0;
+                }
+                .container {
+                  display: grid;
+                  grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+                  gap: 10px;
+                  padding: 10px;
+                }
+                .item {
+                  background-color: #333;
+                  padding: 10px;
+                  border-radius: 6px;
+                  text-align: center;
+                  word-break: break-all;
+                  font-size: 14px;
+                  box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+                }
+                h2 {
+                  text-align: center;
+                  margin-top: 0;
+                  color: #4fc3f7;
+                }
+              </style>
+            </head>
+            <body>
+              <h2>Meme Audio List</h2>
+              <div class="container">
+                ${sounds.map(s => `<div class="item">${s.name}</div>`).join('')}
+              </div>
+            </body>
+          </html>
+        `;
+            const page = await ctx.puppeteer.page();
+            await page.setContent(listHtml);
+            const body = await page.$('body');
+            const buffer = await body?.screenshot({ type: 'png' });
+            await page.close();
+            if (buffer)
+                return koishi_1.h.image(buffer, 'image/png');
+            return 'Failed to generate list image.';
+        }
+        if (!name)
+            return 'Please provide a meme name or use -l to list all.';
+        return playSound(name);
+    });
+    ctx.command('memeaudio.random', 'Play a random meme sound')
+        .action(async () => {
+        const randomSound = sounds[Math.floor(Math.random() * sounds.length)];
+        return playSound(randomSound.name);
+    });
+    ctx.setInterval(async () => {
+        if (config.debug)
+            logger.info('Running cache cleanup check...');
+        const now = Date.now();
+        const files = await fs_extra_1.default.readdir(cacheDir);
+        let deletedCount = 0;
+        for (const file of files) {
+            const accessTime = lastAccess.get(file);
+            let shouldDelete = false;
+            if (accessTime) {
+                if (now - accessTime > config.cacheMaxAge) {
+                    shouldDelete = true;
+                }
+            }
+            else {
+                try {
+                    const stats = await fs_extra_1.default.stat(path_1.default.join(cacheDir, file));
+                    if (now - stats.mtimeMs > config.cacheMaxAge) {
+                        shouldDelete = true;
+                    }
+                }
+                catch (e) { }
+            }
+            if (shouldDelete) {
+                await fs_extra_1.default.unlink(path_1.default.join(cacheDir, file)).catch(() => { });
+                lastAccess.delete(file);
+                deletedCount++;
+            }
+        }
+        if (config.debug && deletedCount > 0)
+            logger.info(`Cleanup finished. Deleted ${deletedCount} files.`);
+    }, config.cleanupInterval);
+}