feat: initialize qq plugin

deployment/qq.yml

@@ -0,0 +1,25 @@
+services:
+  napcat:
+    image: mlikiowa/napcat-docker:latest
+    container_name: napcat
+    restart: always
+    # mac_address: 02:42:ac:11:00:02 # 添加MAC地址固化配置
+    environment:
+      - NAPCAT_UID=${NAPCAT_UID}
+      - NAPCAT_GID=${NAPCAT_GID}
+
+    ports:
+      - 3001:3001
+      - 6096:6096
+      - 6097:6097
+      - 6099:6099
+
+    volumes:
+      - ../.data/napcat/config:/app/napcat/config
+      - ../.data/ntqq:/app/.config/QQ
+    networks:
+      - ema-network
+
+networks:
+  ema-network:
+    driver: bridge

docs/plugin.zh-CN.md

@@ -0,0 +1,51 @@
+# 插件
+
+插件是 Ema 的扩展机制，可以通过插件来扩展 Ema 的功能。目前支持的插件有：
+
+- QQ
+
+## 插件配置
+
+目前只有一个环境变量 `EMA_PLUGINS`，用于配置插件列表，多个插件用逗号分隔。例如：
+
+```bash
+EMA_PLUGINS=qq
+```
+
+## 添加插件
+
+插件的命名必须以`ema-plugin-`开头，例如 `ema-plugin-discord`。插件的开发可以通过以下步骤进行：
+
+1. 创建一个插件包，例如 `ema-plugin-discord`。
+2. 在 [`ema-ui/package.json`](/packages/ema-ui/package.json) 的 `peerDependencies` 中添加一行：
+
+```jsonc
+{
+  "peerDependencies": {
+    // PNPM 工作空间依赖
+    "ema-plugin-discord": "workspace:*",
+    // 或外部包依赖
+    "ema-plugin-discord": "^1.0.0",
+  },
+}
+```
+
+3. 重启服务器。
+
+## 插件开发
+
+插件的根文件需要导出 `Plugin` 符号：
+
+```ts
+import type { EmaPluginProvider, Server } from "ema";
+export const Plugin: EmaPluginProvider = class {
+  static name = "QQ";
+  constructor(private readonly server: Server) {}
+  start(): Promise<void> {
+    console.log("[ema-qq] started", !!this.server.chat);
+    return Promise.resolve();
+  }
+};
+```
+
+根据编译错误的指引实现 `ema-plugin-discord` 包。

packages/ema-plugin-qq/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "ema-plugin-qq",
+  "version": "0.1.0",
+  "type": "module",
+  "keywords": [
+    "qq"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EmaFanClub/EverMemoryArchive.git",
+    "directory": "packages/ema-plugin-qq"
+  },
+  "bugs": {
+    "url": "https://github.com/EmaFanClub/EverMemoryArchive/issues"
+  },
+  "dependencies": {
+    "ema": "workspace:*",
+    "node-napcat-ts": "^0.4.20"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  }
+}

packages/ema-plugin-qq/src/index.ts

@@ -0,0 +1,149 @@
+import type { AgentEventContent, EmaPluginProvider, Server } from "ema";
+import { NCWebsocket, type GroupMessage } from "node-napcat-ts";
+import { execSync } from "child_process";
+
+const gitRev = getGitRev();
+const gitRemote = getGitRemote();
+
+const napcat = new NCWebsocket(
+  {
+    protocol: "ws",
+    host: "172.19.0.2",
+    port: 6097,
+    accessToken: process.env.NAPCAT_ACCESS_TOKEN,
+    // 是否需要在触发 socket.error 时抛出错误, 默认关闭
+    throwPromise: true,
+    // ↓ 自动重连(可选)
+    reconnection: {
+      enable: true,
+      attempts: 10,
+      delay: 5000,
+    },
+    // ↓ 是否开启 DEBUG 模式
+  },
+  true,
+);
+
+export const Plugin: EmaPluginProvider = class {
+  static name = "QQ";
+  constructor(private readonly server: Server) {}
+  async start(): Promise<void> {
+    const replyPat = process.env.NAPCAT_REPLY_PATTERN;
+    if (!replyPat) {
+      throw new Error("NAPCAT_REPLY_PATTERN is not set");
+    }
+
+    await napcat.connect();
+
+    const actor = await this.server.getActor(1, 1);
+
+    interface GroupMessageTask {
+      message: GroupMessage;
+    }
+
+    let taskId = 0;
+    const tasks: Record<number, GroupMessageTask> = {};
+    const messageCache = new Map<number, string>();
+
+    actor.subscribe((response) => {
+      console.log("[ema-qq] actor response", response);
+      for (const event of response.events) {
+        console.log("[ema-qq] actor event", event);
+        if (event.type === "runFinished") {
+          const runFinishedEvent =
+            event.content as AgentEventContent<"runFinished">;
+          console.log("[ema-qq] actor run finished", runFinishedEvent);
+          if (runFinishedEvent.ok) {
+            const task = tasks[runFinishedEvent.metadata.taskId];
+            if (!task) {
+              console.error(
+                "[ema-qq] task not found",
+                runFinishedEvent.metadata.taskId,
+              );
+              continue;
+            }
+            const message = task.message;
+            const msg = runFinishedEvent.msg
+              .trim()
+              .replaceAll(
+                gitRev,
+                `[${gitRev}]( ${gitRemote}/commit/${gitRev} )`,
+              );
+            message.quick_action(
+              [
+                {
+                  type: "text",
+                  data: {
+                    text: ` ${msg}`,
+                  },
+                },
+              ],
+              true,
+            );
+          }
+        }
+      }
+    });
+
+    napcat.on("message.group", async (message) => {
+      //  { type: 'reply', data: [Object] },
+      console.log("[ema-qq] group message");
+      console.log("[ema-qq] group message", message);
+
+      if (!message.raw_message.includes(replyPat)) {
+        console.log("message ignored");
+        return;
+      }
+      let replyContext = "";
+      const reply = message.message.find((m) => m.type === "reply");
+      if (reply) {
+        const replyId = Number.parseInt(reply?.data.id);
+        if (replyId && !Number.isNaN(replyId)) {
+          const cached = messageCache.get(replyId);
+          if (cached) {
+            replyContext = cached;
+          } else {
+            const msg = await napcat.get_msg({ message_id: replyId });
+            if (msg) {
+              replyContext = msg.raw_message;
+              messageCache.set(replyId, replyContext);
+            }
+          }
+        }
+      }
+      messageCache.set(message.message_id, message.raw_message);
+
+      const id = taskId++;
+      tasks[id] = { message };
+
+      let contentList = [];
+      if (replyContext) {
+        contentList.push(`注意：这则消息是在回复：<Reply>`);
+        contentList.push(replyContext);
+        contentList.push(`</Reply>`);
+      }
+      contentList.push(message.raw_message);
+      // current time
+      contentList.push(`当前时间：<Time>${new Date().toLocaleString()}</Time>`);
+      contentList.push(`GitRev（分支）：<Rev>${gitRev}</Rev>`);
+
+      const content = contentList.join("\n");
+
+      actor.work({
+        metadata: { taskId: id },
+        inputs: [{ kind: "text", content }],
+      });
+    });
+
+    return Promise.resolve();
+  }
+};
+
+function getGitRev(): string {
+  // git commit hash
+  return execSync("git rev-parse HEAD").toString().trim();
+}
+
+function getGitRemote(): string {
+  return execSync("git remote get-url origin").toString().trim();
+}

packages/ema-plugin-qq/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "verbatimModuleSyntax": true,
+    "experimentalDecorators": true,
+    "skipLibCheck": true,
+    "types": ["vitest/globals", "node"],
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

packages/ema-ui/instrumentation-node.ts

@@ -0,0 +1,8 @@
+import { getServer } from "@/app/api/shared-server";
+import { loadPlugins } from "@/plugin";
+
+getServer()
+  .then(loadPlugins)
+  .catch((error) => {
+    console.error("Failed to load plugins:", error);
+  });

packages/ema-ui/instrumentation.ts

@@ -0,0 +1,9 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    await import("./instrumentation-node");
+  }
+
+  if (process.env.NEXT_RUNTIME === "edge") {
+    console.warn("Edge runtime is not supported yet");
+  }
+}

packages/ema-ui/package.json

@@ -17,6 +17,9 @@
     "@lancedb/lancedb": "^0.23.0",
     "mongodb": "^7.0.0"
   },
+  "peerDependencies": {
+    "ema-plugin-qq": "workspace:*"
+  },
   "devDependencies": {
     "@next/env": "^16.1.0",
     "@types/node": "^20",

packages/ema-ui/src/app/api/actor/input/route.ts

@@ -32,7 +32,7 @@ export const POST = postBody(ActorInputRequest)(async (body) => {
   const actor = await server.getActor(body.userId, body.actorId);
 
   // Processes input.
-  await actor.work(body.inputs);
+  await actor.work({ inputs: body.inputs });
 
   return new Response(JSON.stringify({ success: true }), {
     status: 200,

packages/ema-ui/src/plugin.ts

@@ -0,0 +1,77 @@
+import type { EmaPluginModule, Server } from "ema";
+import * as fs from "fs";
+
+/**
+ * Loads plugins by environment variable `EMA_PLUGINS`
+ * @param server - The server instance
+ */
+export async function loadPlugins(server: Server): Promise<void> {
+  /**
+   * Comma-separated list of plugins to load
+   *
+   * @example
+   * EMA_PLUGINS=qq,discord
+   */
+  const enabledPlugins = new Set(
+    (process.env.EMA_PLUGINS ?? "")
+      .split(",")
+      .map((name) => name.trim())
+      .filter((name) => name.length > 0),
+  );
+
+  await Promise.all(
+    getPluginModules()
+      .filter((name) => enabledPlugins.has(name))
+      .map(async (name: string) => {
+        try {
+          const m: EmaPluginModule = await import(`ema-plugin-${name}`);
+          if (m.Plugin.name in server.plugins) {
+            throw new Error(`Plugin ${m.Plugin.name} already loaded`);
+          }
+
+          const plugin = new m.Plugin(server);
+
+          server.plugins[m.Plugin.name] = plugin;
+        } catch (error) {
+          console.error(`Failed to load plugin package "${name}":`, error);
+          return;
+        }
+      }),
+  );
+
+  const plugins = Object.entries(server.plugins);
+  await Promise.all(
+    plugins.map(async ([name, plugin]) => {
+      if (!plugin) {
+        return;
+      }
+      try {
+        return await plugin.start();
+      } catch (error) {
+        console.error(`Failed to start plugin "${name}":`, error);
+      }
+    }),
+  );
+}
+
+/**
+ * Finds all plugin modules in the `ema-ui` package.json
+ *
+ * @returns The names of the plugin modules
+ */
+function getPluginModules(): string[] {
+  const dependencies = new Set<string>();
+  const addOne = (name: string) => {
+    if (name.startsWith("ema-plugin-")) {
+      dependencies.add(name.slice("ema-plugin-".length));
+    }
+  };
+
+  const packageJsonData = JSON.parse(
+    fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8"),
+  );
+
+  Object.keys(packageJsonData.dependencies || {}).forEach(addOne);
+  Object.keys(packageJsonData.peerDependencies || {}).forEach(addOne);
+  return Array.from(dependencies).sort();
+}