karin-plugin-ffmpegrender 0.0.1

package/README.md

@@ -0,0 +1,45 @@
+# karin-plugin-ffmpegrender
+
+基于 `ffmpeg` 的 Karin 图片渲染器（渲染 ID：`ffmpeg`），通过 `*.ffrender.json` 描述图层合成并输出图片 base64。
+
+## 功能
+
+- 图片渲染：本地图片 / http 图片 → base64
+- 轻量排版：图片 + 文字（`drawtext`）+ 简单布局
+- 模板渲染：支持 `renderTpl`（`data` 注入），模板渲染后会生成到 `@karinjs/temp/html/...`
+
+## 依赖
+
+- 需要可用的 `ffmpeg`（PATH 或配置 `ffmpegPath`）
+- 如需文字渲染，建议配置 `ffmpegFontFile`（或使用自动探测的系统字体）
+
+## 配置
+
+文件：`@karinjs/karin-plugin-ffmpegrender/config/config.json`
+
+```json
+{
+  "ffmpegPath": "",
+  "ffmpegFontFile": "",
+  "ffmpegTimeoutMs": 30000,
+  "ffmpegLogCommand": false
+}
+```
+
+## Demo 指令
+
+- `#ffmpeg渲染`：基础示例（`resources/template/ffmpeg.ffrender.json`）
+- `#ffmpeg排版`：图片 + 文字 + 简易排版（`resources/template/ffmpeg.card.ffrender.json`）
+
+## 代码调用
+
+```ts
+const img = await render.render({
+  file: '/abs/path/to/template.ffrender.json',
+  type: 'png',
+  data: { file: '/abs/path/to/bg.png' }
+}, 'ffmpeg')
+```
+
+更多说明见：`docs/ffmpeg-renderer.md`
+

package/config/config.json

@@ -0,0 +1,7 @@
+{
+  "yiyanApi": "https://api.yujn.cn/api/sjyy.php",
+  "ffmpegPath": "",
+  "ffmpegFontFile": "",
+  "ffmpegTimeoutMs": 30000,
+  "ffmpegLogCommand": false
+}

package/lib/apps/example.js

@@ -0,0 +1,41 @@
+// src/apps/example.ts
+import { karin, segment } from "node-karin";
+var hello = karin.command("^(#)?\u4F60\u597D$", async (e) => {
+  await e.reply("\u4F60\u597D\u554A\uFF01\u6211\u662FKarin\uFF0C\u5F88\u9AD8\u5174\u8BA4\u8BC6\u4F60~ (\u3002\u30FB\u2200\u30FB)\u30CE", { at: false, recallMsg: 0, reply: true });
+  return true;
+});
+var test = karin.command("^(#)?\u6D4B\u8BD5$", "\u8BA9\u6211\u6765\u5C55\u793A\u4E00\u4E0B\u6211\u7684\u529F\u80FD\u5427\uFF01\u2728");
+var text = karin.command("^(#)?\u6253\u62DB\u547C$", segment.text("\u5927\u5BB6\u597D\u5440\uFF01\u4ECA\u5929\u4E5F\u8981\u5143\u6C14\u6EE1\u6EE1\u54E6\uFF01\u2570(*\xB0\u25BD\xB0*)\u256F"), { name: "\u6253\u62DB\u547C" });
+var test2 = karin.command("^(#)?\u83DC\u5355$", "\u6765\u770B\u770B\u6211\u90FD\u4F1A\u4E9B\u4EC0\u4E48\u5427~\n- #\u4F60\u597D\uFF1A\u6253\u4E2A\u62DB\u547C\n- #\u6D4B\u8BD5\uFF1A\u529F\u80FD\u5C55\u793A\n- #\u6253\u62DB\u547C\uFF1A\u5143\u6C14\u95EE\u5019\n(\uFF61\uFF65\u03C9\uFF65\uFF61)\uFF89\u2661", {
+  event: "message",
+  // 监听的事件
+  name: "\u83DC\u5355",
+  // 插件名称
+  perm: "all",
+  // 触发权限
+  at: false,
+  // 是否加上at 仅在群聊中有效
+  reply: false,
+  // 是否加上引用回复
+  recallMsg: 0,
+  // 发送是否撤回消息 单位秒
+  log: true,
+  // 是否启用日志
+  rank: 1e4,
+  // 优先级
+  adapter: [],
+  // 生效的适配器
+  dsbAdapter: [],
+  // 禁用的适配器
+  delay: 0,
+  // 延迟回复 单位毫秒 仅在第二个参数非函数时有效
+  stop: false,
+  // 是否停止执行后续插件 仅在第二个参数非函数时有效
+  authFailMsg: "\u54CE\u5440\uFF0C\u8FD9\u4E2A\u529F\u80FD\u53EA\u6709\u4E3B\u4EBA\u624D\u80FD\u7528\u54E6\uFF01\u8981\u4E0D\u4F60\u5148\u8BB8\u4E2A\u613F\uFF1F(\u0E51\u2022\u0300\u3142\u2022\u0301)\u0648\u2727"
+});
+export {
+  hello,
+  test,
+  test2,
+  text
+};

package/lib/apps/ffmpegCardDemo.js

@@ -0,0 +1,42 @@
+import {
+  dir
+} from "../chunk-NF24Q4FD.js";
+
+// src/apps/ffmpegCardDemo.ts
+import path from "path";
+import { karin, render, segment, logger } from "node-karin";
+var ffmpegCardDemo = karin.command(/^#?ffmpeg排版$/, async (e) => {
+  try {
+    const spec = path.join(dir.pluginDir, "resources", "template", "ffmpeg.card.ffrender.json");
+    const bg = path.join(dir.pluginDir, "resources", "image", "\u542F\u7A0B\u5BA3\u53D1.png");
+    const now = /* @__PURE__ */ new Date();
+    const footer = `user: ${e.user_id} \xB7 ${now.toLocaleString("zh-CN", { hour12: false })}`;
+    const img = await render.render({
+      name: "ffmpegrender",
+      file: spec,
+      type: "png",
+      data: {
+        file: bg,
+        title: "Karin FFmpeg \u6E32\u67D3",
+        subtitle: "\u56FE\u7247 + \u6587\u5B57 + \u7B80\u6613\u6392\u7248",
+        tag: "render id: ffmpeg",
+        desc: "spec(JSON) \u2192 filter_complex \u2192 base64\n\u652F\u6301\uFF1Acover/contain\u3001\u900F\u660E\u80CC\u666F\u3001\u6587\u5B57\u6846",
+        footer
+      }
+    }, "ffmpeg");
+    await e.reply(segment.image(`base64://${img}`));
+    return true;
+  } catch (error) {
+    logger.error(error);
+    await e.reply(String(error?.message || error));
+    return true;
+  }
+}, {
+  name: "ffmpeg\u6392\u7248demo",
+  priority: 9999,
+  log: true,
+  permission: "all"
+});
+export {
+  ffmpegCardDemo
+};

package/lib/apps/ffmpegDemo.js

@@ -0,0 +1,33 @@
+import {
+  dir
+} from "../chunk-NF24Q4FD.js";
+
+// src/apps/ffmpegDemo.ts
+import path from "path";
+import { karin, render, segment, logger } from "node-karin";
+var ffmpegDemo = karin.command(/^#?ffmpeg渲染$/, async (e) => {
+  try {
+    const spec = path.join(dir.pluginDir, "resources", "template", "ffmpeg.ffrender.json");
+    const bg = path.join(dir.pluginDir, "resources", "image", "\u542F\u7A0B\u5BA3\u53D1.png");
+    const img = await render.render({
+      name: "ffmpegrender",
+      file: spec,
+      type: "png",
+      data: { file: bg }
+    }, "ffmpeg");
+    await e.reply(segment.image(`base64://${img}`));
+    return true;
+  } catch (error) {
+    logger.error(error);
+    await e.reply(String(error?.message || error));
+    return true;
+  }
+}, {
+  name: "ffmpeg\u6E32\u67D3demo",
+  priority: 9999,
+  log: true,
+  permission: "all"
+});
+export {
+  ffmpegDemo
+};

package/lib/apps/ffmpegRenderer.js

@@ -0,0 +1,391 @@
+import {
+  config
+} from "../chunk-2536PGJ3.js";
+import "../chunk-NF24Q4FD.js";
+
+// src/apps/ffmpegRenderer.ts
+import { getRenderList as getRenderList2, logger as logger2, render } from "node-karin";
+
+// src/ffmpeg/renderer.ts
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import crypto from "crypto";
+import os from "os";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { config as karinConfig, getRenderList, karinPathTemp, logger, renderTpl } from "node-karin";
+var RENDER_ID = "ffmpeg";
+var isHttpUrl = (input) => /^https?:\/\//i.test(input);
+var isFileUrl = (input) => /^file:\/\//i.test(input);
+var toFsPath = (input) => {
+  if (!isFileUrl(input)) return input;
+  const stripped = input.replace(/^file:\/\//i, "");
+  if (/^\/[A-Za-z]:[\\/]/.test(stripped)) return stripped.slice(1);
+  if (/^[A-Za-z]:[\\/]/.test(stripped)) return stripped;
+  try {
+    return fileURLToPath(input);
+  } catch {
+    return stripped;
+  }
+};
+var isLikelyImage = (input) => {
+  const clean = input.split("?")[0]?.split("#")[0] ?? input;
+  const ext = path.extname(clean).toLowerCase();
+  return [".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp"].includes(ext);
+};
+var parseHexColor = (color) => {
+  const c = color.trim();
+  if (!c.startsWith("#")) return null;
+  const hex = c.slice(1);
+  if (!/^[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(hex)) return null;
+  const rgb = hex.slice(0, 6).toLowerCase();
+  if (hex.length === 8) {
+    const a = Number.parseInt(hex.slice(6, 8), 16) / 255;
+    return { rgb, alpha: Number.isFinite(a) ? a : 1 };
+  }
+  return { rgb };
+};
+var toFfmpegColor = (color) => {
+  if (!color) return "black@0.0";
+  const c = color.trim();
+  if (c === "transparent") return "black@0.0";
+  const parsed = parseHexColor(c);
+  if (!parsed) {
+    if (!/^[a-zA-Z0-9#@._-]+$/.test(c)) throw new TypeError(`ffmpegrender: unsafe color value: ${c}`);
+    return c;
+  }
+  if (typeof parsed.alpha === "number") return `0x${parsed.rgb}@${parsed.alpha}`;
+  return `0x${parsed.rgb}`;
+};
+var escapeFilterValue = (value) => {
+  const normalized = value.replace(/\\/g, "/");
+  const escaped = normalized.replace(/'/g, "\\'").replace(/:/g, "\\:");
+  return `'${escaped}'`;
+};
+var resolveFfmpegBin = () => {
+  const cfg = config();
+  const fromPlugin = (cfg.ffmpegPath || "").trim();
+  const fromKarin = (karinConfig.ffmpegPath?.() || "").trim();
+  return fromPlugin || fromKarin || "ffmpeg";
+};
+var findDefaultFontFile = () => {
+  const cfg = config();
+  const configured = (cfg.ffmpegFontFile || "").trim();
+  if (configured && fsSync.existsSync(configured)) return configured;
+  const candidates = process.platform === "win32" ? [
+    "C:/Windows/Fonts/msyh.ttc",
+    "C:/Windows/Fonts/msyh.ttf",
+    "C:/Windows/Fonts/simhei.ttf",
+    "C:/Windows/Fonts/arial.ttf"
+  ] : process.platform === "darwin" ? [
+    "/System/Library/Fonts/Supplemental/Arial.ttf",
+    "/System/Library/Fonts/Supplemental/Helvetica.ttf"
+  ] : [
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+    "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
+    "/usr/share/fonts/truetype/freefont/FreeSans.ttf"
+  ];
+  return candidates.find((p) => fsSync.existsSync(p));
+};
+var resolveTempBaseDir = () => {
+  const base = (karinPathTemp || "").trim() || os.tmpdir();
+  return path.join(base, "ffmpegrender");
+};
+var spawnFfmpeg = async (args) => {
+  const cfg = config();
+  const ffmpegBin = resolveFfmpegBin();
+  const logCmd = Boolean(cfg.ffmpegLogCommand);
+  const timeoutMs = Number.isFinite(cfg.ffmpegTimeoutMs) ? cfg.ffmpegTimeoutMs : 3e4;
+  if (logCmd) logger.mark(`[ffmpeg] ${ffmpegBin} ${args.join(" ")}`);
+  return await new Promise((resolve, reject) => {
+    const child = spawn(ffmpegBin, args, {
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`[ffmpeg] timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+    child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      if (err?.code === "ENOENT") {
+        reject(new Error(`ffmpegrender: ffmpeg not found (${ffmpegBin}); set \`ffmpegPath\` in plugin config or install ffmpeg in PATH`));
+        return;
+      }
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) return resolve(Buffer.concat(stdout));
+      const errText = Buffer.concat(stderr).toString("utf8").trim();
+      reject(new Error(`[ffmpeg] exit ${code}: ${errText || "unknown error"}`));
+    });
+  });
+};
+var assertSpec = (spec) => {
+  if (!spec || typeof spec !== "object") throw new TypeError("ffmpegrender: spec must be an object");
+  const s = spec;
+  if (!Number.isFinite(s.width) || !Number.isFinite(s.height)) {
+    throw new TypeError("ffmpegrender: spec.width/spec.height must be numbers");
+  }
+  if (s.width <= 0 || s.height <= 0) {
+    throw new TypeError("ffmpegrender: spec.width/spec.height must be > 0");
+  }
+  if (s.layers && !Array.isArray(s.layers)) throw new TypeError("ffmpegrender: spec.layers must be an array");
+};
+var buildImageChain = (layer, transparentColor) => {
+  const w = Math.round(layer.width);
+  const h = Math.round(layer.height);
+  const fit = layer.fit || "cover";
+  const filters = ["format=rgba"];
+  if (fit === "contain") {
+    filters.push(`scale=w=${w}:h=${h}:force_original_aspect_ratio=decrease`);
+    filters.push(`pad=w=${w}:h=${h}:x=(ow-iw)/2:y=(oh-ih)/2:color=${transparentColor}`);
+  } else if (fit === "cover") {
+    filters.push(`scale=w=${w}:h=${h}:force_original_aspect_ratio=increase`);
+    filters.push(`crop=w=${w}:h=${h}`);
+  } else {
+    filters.push(`scale=w=${w}:h=${h}`);
+  }
+  if (typeof layer.opacity === "number" && layer.opacity >= 0 && layer.opacity < 1) {
+    filters.push(`colorchannelmixer=aa=${layer.opacity}`);
+  }
+  return filters.join(",");
+};
+var buildDrawtext = async (layer, tempDir) => {
+  const fontFile = layer.fontFile || findDefaultFontFile();
+  if (!fontFile) {
+    throw new Error("ffmpegrender: missing font file (set `ffmpegFontFile` in plugin config or layer.fontFile)");
+  }
+  const id = crypto.randomBytes(8).toString("hex");
+  const textFile = path.join(tempDir, `text-${id}.txt`);
+  await fs.writeFile(textFile, layer.text, "utf8");
+  const opts = [
+    `fontfile=${escapeFilterValue(fontFile)}`,
+    `textfile=${escapeFilterValue(textFile)}`,
+    "reload=0",
+    `x=${Math.round(layer.x)}`,
+    `y=${Math.round(layer.y)}`,
+    `fontsize=${Math.round(layer.fontSize)}`,
+    `fontcolor=${toFfmpegColor(layer.color || "#ffffff")}`
+  ];
+  const boxColor = layer.box?.color ? toFfmpegColor(layer.box.color) : void 0;
+  const border = layer.box?.border;
+  if (boxColor) {
+    opts.push("box=1");
+    opts.push(`boxcolor=${boxColor}`);
+    if (typeof border === "number" && border > 0) opts.push(`boxborderw=${Math.round(border)}`);
+  }
+  return { filter: `drawtext=${opts.join(":")}`, cleanupFile: textFile };
+};
+var normalizeBackgroundImage = (bg, width, height) => {
+  if (!bg?.src) return null;
+  return {
+    type: "image",
+    src: bg.src,
+    x: 0,
+    y: 0,
+    width,
+    height,
+    fit: bg.fit || "cover"
+  };
+};
+var readSpec = async (filePath) => {
+  const raw = await fs.readFile(filePath, "utf8");
+  const spec = JSON.parse(raw);
+  assertSpec(spec);
+  return spec;
+};
+var tryReadSpec = async (filePath) => {
+  try {
+    return await readSpec(filePath);
+  } catch {
+    return null;
+  }
+};
+var renderSpecWithFfmpeg = async (spec, specDir, outType, outQuality) => {
+  const transparentColor = "black@0.0";
+  const bgColor = toFfmpegColor(spec.background?.color);
+  const imageLayers = [];
+  const bgImage = normalizeBackgroundImage(spec.background, spec.width, spec.height);
+  if (bgImage) imageLayers.push(bgImage);
+  for (const layer of spec.layers || []) {
+    if (layer.type === "image") imageLayers.push(layer);
+  }
+  const textLayers = (spec.layers || []).filter((l) => l.type === "text");
+  const inputFiles = imageLayers.map((l) => resolveAsset(l.src, specDir));
+  const tmpBase = resolveTempBaseDir();
+  await fs.mkdir(tmpBase, { recursive: true });
+  const tempDir = await fs.mkdtemp(path.join(tmpBase, "run-"));
+  const textCleanup = [];
+  try {
+    const filterParts = [];
+    filterParts.push("[0:v]format=rgba[base0]");
+    let current = "base0";
+    let step = 0;
+    for (let i = 0; i < imageLayers.length; i++) {
+      const inputIndex = i + 1;
+      const layer = imageLayers[i];
+      const imgLabel = `img${inputIndex}`;
+      filterParts.push(`[${inputIndex}:v]${buildImageChain(layer, transparentColor)}[${imgLabel}]`);
+      const next = `base${++step}`;
+      filterParts.push(`[${current}][${imgLabel}]overlay=${Math.round(layer.x)}:${Math.round(layer.y)}:format=auto[${next}]`);
+      current = next;
+    }
+    for (const layer of textLayers) {
+      const { filter, cleanupFile } = await buildDrawtext(layer, tempDir);
+      textCleanup.push(cleanupFile);
+      const next = `base${++step}`;
+      filterParts.push(`[${current}]${filter}[${next}]`);
+      current = next;
+    }
+    const filterComplex = filterParts.join(";");
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-f",
+      "lavfi",
+      "-i",
+      `color=c=${bgColor}:s=${Math.round(spec.width)}x${Math.round(spec.height)}:d=1`
+    ];
+    for (const input of inputFiles) args.push("-i", input);
+    args.push(
+      "-filter_complex",
+      filterComplex,
+      "-map",
+      `[${current}]`,
+      "-frames:v",
+      "1",
+      "-an",
+      "-sn"
+    );
+    if (outType === "png") {
+      args.push("-f", "image2pipe", "-vcodec", "png", "-pix_fmt", "rgba", "-");
+    } else if (outType === "webp") {
+      args.push("-f", "image2pipe", "-vcodec", "libwebp", "-pix_fmt", "yuva420p", "-");
+    } else {
+      const q = typeof outQuality === "number" ? clamp(outQuality, 1, 100) : 90;
+      const qscale = String(Math.round(31 - q / 100 * 29));
+      args.push("-q:v", qscale, "-f", "image2pipe", "-vcodec", "mjpeg", "-");
+    }
+    const output = await spawnFfmpeg(args);
+    return output;
+  } finally {
+    await Promise.allSettled(textCleanup.map((f) => fs.unlink(f)));
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+};
+var clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+var resolveAsset = (asset, baseDir) => {
+  const src = asset.trim();
+  if (isHttpUrl(src)) return src;
+  const fsPath = toFsPath(src);
+  if (path.isAbsolute(fsPath)) return fsPath;
+  return path.resolve(baseDir, fsPath);
+};
+var delegateToAnotherRenderer = async (options) => {
+  const list = getRenderList();
+  const other = list.find((r) => r.id !== RENDER_ID);
+  if (!other) return null;
+  return await other.render(options);
+};
+var inferOutputType = (options) => {
+  const t = options.type;
+  if (t === "jpeg" || t === "webp" || t === "png") return t;
+  return "png";
+};
+var ffmpegRender = async (options) => {
+  const file = options?.file;
+  if (typeof file !== "string") throw new TypeError("ffmpegrender: options.file must be a string");
+  if (!isHttpUrl(file) && options.data) {
+    options = renderTpl(options);
+  }
+  const normalizedFile = options.file;
+  const outType = inferOutputType(options);
+  const outQuality = options.quality;
+  if (isHttpUrl(normalizedFile) && !isLikelyImage(normalizedFile)) {
+    const delegated2 = await delegateToAnotherRenderer(options);
+    if (delegated2) return delegated2;
+    throw new Error("ffmpegrender: http input is not an image; please install a puppeteer/snapka renderer for HTML/URL rendering");
+  }
+  if (isHttpUrl(normalizedFile) && isLikelyImage(normalizedFile)) {
+    const buffer = await renderImageWithFfmpeg(normalizedFile, outType, outQuality);
+    const b64 = buffer.toString("base64");
+    const multiPage = options.multiPage;
+    if (multiPage) return [b64];
+    return b64;
+  }
+  const fsPath = path.resolve(toFsPath(normalizedFile));
+  if (isLikelyImage(fsPath)) {
+    const buffer = await renderImageWithFfmpeg(fsPath, outType, outQuality);
+    const b64 = buffer.toString("base64");
+    const multiPage = options.multiPage;
+    if (multiPage) return [b64];
+    return b64;
+  }
+  const ext = path.extname(fsPath).toLowerCase();
+  const maybeSpec = ext === ".json" || ext === ".ffrender";
+  if (maybeSpec) {
+    const spec = await tryReadSpec(fsPath);
+    if (spec) {
+      const specDir = path.dirname(fsPath);
+      const buffer = await renderSpecWithFfmpeg(spec, specDir, outType, outQuality);
+      const b64 = buffer.toString("base64");
+      const multiPage = options.multiPage;
+      if (multiPage) return [b64];
+      return b64;
+    }
+  }
+  const delegated = await delegateToAnotherRenderer(options);
+  if (delegated) return delegated;
+  throw new Error(`ffmpegrender: unsupported input: ${normalizedFile}`);
+};
+var renderImageWithFfmpeg = async (input, outType, outQuality) => {
+  const args = [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-i",
+    input,
+    "-frames:v",
+    "1",
+    "-an",
+    "-sn"
+  ];
+  if (outType === "png") {
+    args.push("-f", "image2pipe", "-vcodec", "png", "-pix_fmt", "rgba", "-");
+  } else if (outType === "webp") {
+    args.push("-f", "image2pipe", "-vcodec", "libwebp", "-pix_fmt", "yuva420p", "-");
+  } else {
+    const q = typeof outQuality === "number" ? clamp(outQuality, 1, 100) : 90;
+    const qscale = String(Math.round(31 - q / 100 * 29));
+    args.push("-q:v", qscale, "-f", "image2pipe", "-vcodec", "mjpeg", "-");
+  }
+  return await spawnFfmpeg(args);
+};
+
+// src/apps/ffmpegRenderer.ts
+var RENDER_ID2 = "ffmpeg";
+try {
+  const exists = getRenderList2().some((r) => r.id === RENDER_ID2);
+  if (!exists) {
+    render.app({
+      id: RENDER_ID2,
+      type: "image",
+      render: ffmpegRender
+    });
+    logger2.mark(`[ffmpegrender] renderer registered: ${RENDER_ID2}`);
+  }
+} catch (err) {
+  logger2.error("[ffmpegrender] renderer register failed", err);
+}
+var ffmpegRenderer = RENDER_ID2;
+export {
+  ffmpegRenderer
+};

package/lib/apps/handler.js

@@ -0,0 +1,24 @@
+// src/apps/handler.ts
+import { karin, handler } from "node-karin";
+var test = karin.handler("test.image", (args, reject) => {
+  return "Handler\u5904\u7406\u5B8C\u6210";
+});
+var testHandler = karin.command(/^#?测试handler$/, async (e) => {
+  const msg = "\u6D4B\u8BD5handler";
+  const res = await handler.call("test.image", { e, msg });
+  await e.reply(res);
+  return true;
+}, {
+  /** 插件优先级 */
+  priority: 9999,
+  /** 插件触发是否打印触发日志 */
+  log: true,
+  /** 插件名称 */
+  name: "\u6D4B\u8BD5handler",
+  /** 谁可以触发这个插件 'all' | 'master' | 'admin' | 'group.owner' | 'group.admin' */
+  permission: "all"
+});
+export {
+  test,
+  testHandler
+};

package/lib/apps/render.js

@@ -0,0 +1,89 @@
+import {
+  config
+} from "../chunk-2536PGJ3.js";
+import {
+  dir
+} from "../chunk-NF24Q4FD.js";
+
+// src/apps/render.ts
+import { karin, render, segment, logger } from "node-karin";
+var image = karin.command(/^#?测试渲染$/, async (e) => {
+  try {
+    const html = dir.defResourcesDir + "/template/test.html";
+    const image2 = dir.defResourcesDir + "/image/\u542F\u7A0B\u5BA3\u53D1.png";
+    const img = await render.render({
+      name: "render",
+      encoding: "base64",
+      file: html,
+      data: {
+        file: image2,
+        pluResPath: process.cwd()
+      },
+      pageGotoParams: {
+        waitUntil: "networkidle2"
+      }
+    });
+    await e.reply(segment.image(`base64://${img}`));
+    return true;
+  } catch (error) {
+    logger.error(error);
+    await e.reply(JSON.stringify(error));
+    return true;
+  }
+}, {
+  /** 插件优先级 */
+  priority: 9999,
+  /** 插件触发是否打印触发日志 */
+  log: true,
+  /** 插件名称 */
+  name: "\u6D4B\u8BD5\u6E32\u67D3",
+  /** 谁可以触发这个插件 'all' | 'master' | 'admin' | 'group.owner' | 'group.admin' */
+  permission: "all"
+});
+var renderUrl = karin.command(/^#?渲染/, async (e) => {
+  const file = e.msg.replace(/^#?渲染/, "").trim();
+  try {
+    const img = await render.render({
+      name: "render",
+      encoding: "base64",
+      file: file || "https://whitechi73.github.io/OpenShamrock/",
+      type: "png",
+      pageGotoParams: {
+        waitUntil: "networkidle2"
+      },
+      setViewport: {
+        width: 1920,
+        height: 1080,
+        deviceScaleFactor: 1
+      }
+    });
+    await e.reply(segment.image(`base64://${img}`));
+    return true;
+  } catch (error) {
+    logger.error(error);
+    await e.reply(error.message);
+    return true;
+  }
+}, {
+  /** 插件优先级 */
+  priority: 9999,
+  /** 插件触发是否打印触发日志 */
+  log: true,
+  /** 插件名称 */
+  name: "\u6E32\u67D3demo",
+  /** 谁可以触发这个插件 'all' | 'master' | 'admin' | 'group.owner' | 'group.admin' */
+  permission: "master"
+});
+var screenshot = karin.command("^#\u6D4B\u8BD5\u622A\u56FE$", async (e) => {
+  const { screenshotUrl } = config();
+  const img = await karin.render(screenshotUrl);
+  await e.reply(segment.image(`base64://${img}`));
+  return true;
+}, {
+  name: "\u6D4B\u8BD5\u622A\u56FE"
+});
+export {
+  image,
+  renderUrl,
+  screenshot
+};

package/lib/apps/sendMsg.js

@@ -0,0 +1,128 @@
+import {
+  config
+} from "../chunk-2536PGJ3.js";
+import "../chunk-NF24Q4FD.js";
+
+// src/apps/sendMsg.ts
+import { karin, segment, common } from "node-karin";
+var yiyanApi = karin.command(/^#一言$/, async (e) => {
+  const { yiyanApi: yiyanApi2 } = config();
+  await e.reply(segment.image(yiyanApi2));
+}, {
+  name: "\u4E00\u8A00api"
+});
+var sendMsg = karin.command(/^#测试主动消息$/, async (e) => {
+  const selfId = e.selfId;
+  const contact = e.contact;
+  const messages = [
+    "\u2728 \u54C7\uFF01\u8FD9\u662F\u4E00\u6761\u8D85\u53EF\u7231\u7684\u4E3B\u52A8\u6D88\u606F\uFF0C10\u79D2\u540E\u5C31\u4F1A\u795E\u79D8\u6D88\u5931\u54E6~ \u2728",
+    "\u{1F338} \u53EE\u549A\uFF01\u6211\u4E3B\u52A8\u627E\u4F60\u804A\u5929\u5566\uFF0C\u53EF\u60DC10\u79D2\u540E\u6211\u5C31\u8981\u6E9C\u8D70\u5566~ \u{1F338}",
+    "\u{1F380} \u4F60\u597D\u5440\uFF01\u8FD9\u662F\u4E00\u6761\u4F1A\u81EA\u5DF1\u8DD1\u6389\u7684\u6D88\u606F\uFF0C\u5012\u8BA1\u65F610\u79D2\u5F00\u59CB\uFF01\u{1F380}",
+    "\u{1F36D} \u7A81\u7136\u51FA\u73B0\u7684\u751C\u751C\u6D88\u606F\uFF01\u522B\u6025\u7740\u56DE\u590D\uFF0C10\u79D2\u540E\u6211\u5C31\u6D88\u5931\u5566~ \u{1F36D}"
+  ];
+  const randomMsg = messages[Math.floor(Math.random() * messages.length)];
+  const text = `
+${randomMsg}`;
+  const { messageId } = await karin.sendMsg(selfId, contact, text, { recallMsg: 10 });
+  console.log(`\u2705 \u6D88\u606F\u5DF2\u9001\u8FBE\uFF0C\u6D88\u606FID\uFF1A${messageId}`);
+  return true;
+}, {
+  /** 插件优先级 */
+  priority: 9999,
+  /** 插件触发是否打印触发日志 */
+  log: true,
+  /** 插件名称 */
+  name: "\u53EF\u7231\u4E3B\u52A8\u6D88\u606Fdemo",
+  /** 谁可以触发这个插件 'all' | 'master' | 'admin' | 'group.owner' | 'group.admin' */
+  permission: "all"
+});
+var forwardMessage = karin.command(/^#测试转发$/, async (e) => {
+  const message = [
+    segment.text("\u{1F31F} \u8FD9\u662F\u8F6C\u53D1\u7684\u7B2C\u4E00\u6761\u6D88\u606F \u{1F31F}"),
+    segment.text("\u2728 \u8FD9\u662F\u8F6C\u53D1\u7684\u7B2C\u4E8C\u6761\u6D88\u606F \u2728"),
+    segment.text("\u{1F496} \u8FD9\u662F\u8F6C\u53D1\u7684\u6700\u540E\u4E00\u6761\u6D88\u606F \u{1F496}")
+  ];
+  const content = common.makeForward(message, e.selfId, e.bot.account.name);
+  await e.bot.sendForwardMsg(e.contact, content);
+  return true;
+}, {
+  /** 插件优先级 */
+  priority: 9999,
+  /** 插件触发是否打印触发日志 */
+  log: true,
+  /** 插件名称 */
+  name: "\u53EF\u7231\u8F6C\u53D1demo",
+  /** 谁可以触发这个插件 'all' | 'master' | 'admin' | 'group.owner' | 'group.admin' */
+  permission: "all"
+});
+var randomEmoji = karin.command(/^#随机表情$/, async (e) => {
+  const emojiUrls = [
+    "https://i.imgur.com/XaUdU2C.gif",
+    "https://i.imgur.com/wF2RkHB.gif",
+    "https://i.imgur.com/7voHalT.jpg",
+    "https://i.imgur.com/QMlZUdZ.gif",
+    "https://i.imgur.com/o2JQjAn.gif"
+  ];
+  const randomUrl = emojiUrls[Math.floor(Math.random() * emojiUrls.length)];
+  const message = [
+    segment.text("\u{1F389} \u968F\u673A\u8868\u60C5\u5305\u6765\u5566\uFF01"),
+    segment.image(randomUrl)
+  ];
+  await e.reply(message);
+  return true;
+}, {
+  priority: 9999,
+  log: true,
+  name: "\u968F\u673A\u8868\u60C5\u5305demo",
+  permission: "all"
+});
+var dailyQuote = karin.command(/^#每日一言$/, async (e) => {
+  const quotes = [
+    "\u4ECA\u5929\u4E5F\u662F\u5145\u6EE1\u5E0C\u671B\u7684\u4E00\u5929\uFF01\u52A0\u6CB9\uFF01\u2728",
+    "\u4EBA\u751F\u5C31\u50CF\u4E00\u76D2\u5DE7\u514B\u529B\uFF0C\u4F60\u6C38\u8FDC\u4E0D\u77E5\u9053\u4E0B\u4E00\u5757\u662F\u4EC0\u4E48\u5473\u9053\u3002\u{1F36B}",
+    "\u5FAE\u7B11\u662F\u4E16\u754C\u4E0A\u6700\u7F8E\u4E3D\u7684\u8BED\u8A00\u3002\u{1F60A}",
+    "\u6210\u529F\u4E0D\u662F\u7EC8\u70B9\uFF0C\u5931\u8D25\u4E5F\u4E0D\u662F\u7EC8\u7ED3\uFF0C\u91CD\u8981\u7684\u662F\u7EE7\u7EED\u524D\u8FDB\u7684\u52C7\u6C14\u3002\u{1F680}",
+    "\u505A\u81EA\u5DF1\u7684\u592A\u9633\uFF0C\u4E0D\u5FC5\u4EF0\u671B\u522B\u4EBA\uFF01\u{1F4AB}",
+    "\u751F\u6D3B\u5C31\u50CF\u9A91\u81EA\u884C\u8F66\uFF0C\u60F3\u4FDD\u6301\u5E73\u8861\u5C31\u5F97\u524D\u8FDB\u3002\u{1F6B2}",
+    "\u6700\u91CD\u8981\u7684\u662F\u7231\u81EA\u5DF1\uFF0C\u56E0\u4E3A\u8FD9\u6837\u4F60\u7684\u7075\u9B42\u624D\u4F1A\u53D1\u5149\u3002\u{1F496}"
+  ];
+  const randomQuote = quotes[Math.floor(Math.random() * quotes.length)];
+  const message = [
+    segment.text(`\u{1F4AD} \u6BCF\u65E5\u4E00\u8A00\uFF1A${randomQuote}`)
+  ];
+  await e.reply(message);
+  return true;
+}, {
+  priority: 9999,
+  log: true,
+  name: "\u6BCF\u65E5\u4E00\u8A00demo",
+  permission: "all"
+});
+var weatherForecast = karin.command(/^#今日天气$/, async (e) => {
+  const weathers = [
+    "\u2600\uFE0F \u6674\u5929\uFF0C\u6E29\u5EA625\xB0C\uFF0C\u9002\u5408\u51FA\u95E8\u73A9\u800D~",
+    "\u{1F327}\uFE0F \u5C0F\u96E8\uFF0C\u6E29\u5EA618\xB0C\uFF0C\u8BB0\u5F97\u5E26\u4F1E\u54E6\uFF01",
+    "\u26C5 \u591A\u4E91\uFF0C\u6E29\u5EA622\xB0C\uFF0C\u9634\u6674\u4E0D\u5B9A\u7684\u4E00\u5929~",
+    "\u{1F32B}\uFE0F \u96FE\u5929\uFF0C\u6E29\u5EA615\xB0C\uFF0C\u80FD\u89C1\u5EA6\u8F83\u4F4E\uFF0C\u51FA\u884C\u6CE8\u610F\u5B89\u5168\uFF01",
+    "\u{1F324}\uFE0F \u5C40\u90E8\u6674\u6717\uFF0C\u6E29\u5EA620\xB0C\uFF0C\u5076\u6709\u5C0F\u4E91\u6735\u906E\u6321\u9633\u5149~"
+  ];
+  const randomWeather = weathers[Math.floor(Math.random() * weathers.length)];
+  const message = [
+    segment.text(`\u{1F308} \u4ECA\u65E5\u5929\u6C14\u9884\u62A5\uFF1A${randomWeather}`)
+  ];
+  await e.reply(message);
+  return true;
+}, {
+  priority: 9999,
+  log: true,
+  name: "\u5929\u6C14\u9884\u62A5demo",
+  permission: "all"
+});
+export {
+  dailyQuote,
+  forwardMessage,
+  randomEmoji,
+  sendMsg,
+  weatherForecast,
+  yiyanApi
+};

package/lib/apps/task.js

@@ -0,0 +1,19 @@
+// src/apps/task.ts
+import { karin, logger } from "node-karin";
+var Task = karin.task("\u6BCF\u5206\u949F\u7684\u8DA3\u5473\u95EE\u5019", "0 */1 * * * *", () => {
+  const funnyMessages = [
+    "\u4F60\u597D\u5440\uFF0C\u53C8\u89C1\u9762\u4E86\uFF01",
+    "\u53C8\u8FC7\u53BB\u4E00\u5206\u949F\uFF0C\u6211\u8FD8\u5728\u575A\u6301\u5DE5\u4F5C~",
+    "\u563F\uFF0C\u770B\u770B\u8C01\u53C8\u6309\u65F6\u62A5\u5230\u4E86\uFF01",
+    "\u65F6\u95F4\u8FC7\u5F97\u771F\u5FEB\uFF0C\u6211\u90FD\u6570\u4E0D\u6E05\u8FD9\u662F\u7B2C\u51E0\u6B21\u89C1\u4F60\u4E86",
+    "\u53EE\u549A\uFF01\u60A8\u7684\u6BCF\u5206\u949F\u63D0\u9192\u670D\u52A1\u5DF2\u9001\u8FBE",
+    "\u5DE5\u4F5Cing...\u522B\u62C5\u5FC3\uFF0C\u6211\u4E0D\u4F1A\u5077\u61D2\u7684",
+    "\u6EF4\u7B54\u6EF4\u7B54\uFF0C\u65F6\u949F\u5728\u8D70\uFF0C\u6211\u5728\u966A\u4F60",
+    "\u6211\u662F\u6700\u52E4\u52B3\u7684\u4EFB\u52A1\uFF0C\u4ECE\u4E0D\u7F3A\u52E4\uFF01"
+  ];
+  const randomIndex = Math.floor(Math.random() * funnyMessages.length);
+  logger.info(`\u{1F389} ${funnyMessages[randomIndex]} \u{1F389}`);
+}, { log: false });
+export {
+  Task
+};

package/lib/chunk-2536PGJ3.js

@@ -0,0 +1,61 @@
+import {
+  dir
+} from "./chunk-NF24Q4FD.js";
+
+// src/utils/config.ts
+import fs from "fs";
+import path from "path";
+import {
+  watch,
+  logger,
+  filesByExt,
+  copyConfigSync,
+  requireFileSync
+} from "node-karin";
+copyConfigSync(dir.defConfigDir, dir.ConfigDir, [".json"]);
+var copyDirMissingSync = (srcDir, destDir) => {
+  if (!fs.existsSync(srcDir)) return;
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirMissingSync(srcPath, destPath);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!fs.existsSync(destPath)) {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+};
+try {
+  copyDirMissingSync(path.join(dir.pluginDir, "resources"), dir.defResourcesDir);
+} catch (err) {
+  logger.error("[ffmpegrender] copy resources failed", err);
+}
+var config = () => {
+  const cfg = requireFileSync(`${dir.ConfigDir}/config.json`);
+  const def = requireFileSync(`${dir.defConfigDir}/config.json`);
+  return { ...def, ...cfg };
+};
+setTimeout(() => {
+  const list = filesByExt(dir.ConfigDir, ".json", "abs");
+  list.forEach((file) => watch(file, (old, now) => {
+    logger.info([
+      "QAQ: \u68C0\u6D4B\u5230\u914D\u7F6E\u6587\u4EF6\u66F4\u65B0",
+      `\u8FD9\u662F\u65E7\u6570\u636E: ${old}`,
+      `\u8FD9\u662F\u65B0\u6570\u636E: ${now}`
+    ].join("\n"));
+  }));
+}, 2e3);
+
+// src/utils/common.ts
+import lodash from "node-karin/lodash";
+import moment from "node-karin/moment";
+
+export {
+  config
+};

package/lib/chunk-NF24Q4FD.js

@@ -0,0 +1,43 @@
+// src/dir.ts
+import path from "path";
+import { URL, fileURLToPath } from "url";
+import { karinPathBase, requireFileSync } from "node-karin";
+var pluginDir = fileURLToPath(new URL("../", import.meta.url));
+var pluginName = path.basename(pluginDir);
+var pkg = requireFileSync(path.join(pluginDir, "package.json"));
+var dir = {
+  /** 根目录绝对路径 */
+  pluginDir,
+  /** 插件目录名称 */
+  pluginName,
+  /** package.json */
+  pkg,
+  /** 插件版本 package.json 的 version */
+  get version() {
+    return pkg.version;
+  },
+  /** 插件名称 package.json 的 name */
+  get name() {
+    return pkg.name;
+  },
+  /** 插件默认配置目录 */
+  get defConfigDir() {
+    return path.join(pluginDir, "config");
+  },
+  /** 在`@karinjs`中的绝对路径 */
+  get karinPath() {
+    return path.join(karinPathBase, pluginName);
+  },
+  /** 插件配置目录 `@karinjs/karin-plugin-xxx/config` */
+  get ConfigDir() {
+    return path.join(this.karinPath, "config");
+  },
+  /** 插件资源目录 `@karinjs/karin-plugin-xxx/resources` */
+  get defResourcesDir() {
+    return path.join(this.karinPath, "resources");
+  }
+};
+
+export {
+  dir
+};

package/lib/dir.js

@@ -0,0 +1,6 @@
+import {
+  dir
+} from "./chunk-NF24Q4FD.js";
+export {
+  dir
+};

package/lib/index.js

@@ -0,0 +1,7 @@
+import {
+  dir
+} from "./chunk-NF24Q4FD.js";
+
+// src/index.ts
+import { logger } from "node-karin";
+logger.info(`${logger.violet(`[\u63D2\u4EF6:${dir.version}]`)} ${logger.green(dir.name)} \u521D\u59CB\u5316\u5B8C\u6210~`);

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "karin-plugin-ffmpegrender",
+  "version": "0.0.1",
+  "author": "429",
+  "type": "module",
+  "description": "karin plugin template",
+  "homepage": "https://github.com/KarinJS/karin",
+  "bugs": {
+    "url": "https://github.com/KarinJS/karin/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KarinJS/karin.git"
+  },
+  "scripts": {
+    "app": "node lib/app.js",
+    "build": "tsup",
+    "dev": "cross-env EBV_FILE=\"development.env\" node --import tsx src/app.ts",
+    "pub": "npm publish --access public"
+  },
+  "main": "lib/index.js",
+  "devDependencies": {
+    "@types/express": "^5.0.1",
+    "@types/lodash": "^4.17.16",
+    "@types/node": "^20.17.8",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.7.0",
+    "neostandard": "^0.11.9",
+    "node-karin": "*",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.5.3"
+  },
+  "karin": {
+    "main": "src/index.ts",
+    "apps": [
+      "lib/apps"
+    ],
+    "ts-apps": [
+      "src/apps"
+    ],
+    "static": [
+      "resources"
+    ],
+    "files": [
+      "config",
+      "data",
+      "resources"
+    ]
+  },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "/config/*.json",
+    "resources",
+    "!lib/app.js"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@karinjs/plugin-puppeteer": "^1.1.2"
+  }
+}

package/resources/template/ffmpeg.card.ffrender.json

@@ -0,0 +1,62 @@
+{
+  "width": 960,
+  "height": 540,
+  "background": {
+    "color": "#ffffffff"
+  },
+  "layers": [
+    {
+      "type": "image",
+      "src": "{{@(file || '').replace(/\\/g, '/')}}",
+      "x": 40,
+      "y": 60,
+      "width": 320,
+      "height": 420,
+      "fit": "cover"
+    },
+    {
+      "type": "text",
+      "text": "{{@(title || '').replace(/\\/g, '\\\\').replace(/\"/g, '\\\"').replace(/\r?\n/g, '\\n')}}",
+      "x": 390,
+      "y": 90,
+      "fontSize": 44,
+      "color": "#111111"
+    },
+    {
+      "type": "text",
+      "text": "{{@(subtitle || '').replace(/\\/g, '\\\\').replace(/\"/g, '\\\"').replace(/\r?\n/g, '\\n')}}",
+      "x": 390,
+      "y": 160,
+      "fontSize": 26,
+      "color": "#555555"
+    },
+    {
+      "type": "text",
+      "text": "{{@(tag || '').replace(/\\/g, '\\\\').replace(/\"/g, '\\\"').replace(/\r?\n/g, '\\n')}}",
+      "x": 390,
+      "y": 220,
+      "fontSize": 22,
+      "color": "#2b6cb0",
+      "box": {
+        "color": "#2b6cb033",
+        "border": 10
+      }
+    },
+    {
+      "type": "text",
+      "text": "{{@(desc || '').replace(/\\/g, '\\\\').replace(/\"/g, '\\\"').replace(/\r?\n/g, '\\n')}}",
+      "x": 390,
+      "y": 280,
+      "fontSize": 24,
+      "color": "#222222"
+    },
+    {
+      "type": "text",
+      "text": "{{@(footer || '').replace(/\\/g, '\\\\').replace(/\"/g, '\\\"').replace(/\r?\n/g, '\\n')}}",
+      "x": 40,
+      "y": 505,
+      "fontSize": 18,
+      "color": "#666666"
+    }
+  ]
+}

package/resources/template/ffmpeg.ffrender.json

@@ -0,0 +1,18 @@
+{
+  "width": 1067,
+  "height": 600,
+  "background": {
+    "color": "#00000000"
+  },
+  "layers": [
+    {
+      "type": "image",
+      "src": "{{@(file || '').replace(/\\/g, '/')}}",
+      "x": 0,
+      "y": 0,
+      "width": 1067,
+      "height": 600,
+      "fit": "cover"
+    }
+  ]
+}

package/resources/template/test.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <style>
+    body {
+      width: 1067px;
+      height: 600px;
+      margin: 0;
+      padding: 0;
+      background-size: cover;
+    }
+  </style>
+</head>
+
+<body>
+  <!-- 本地图片 -->
+  <img src="{{@file}}" alt="启程宣发">
+</body>
+
+</html>