luckytri 1.0.0

package/server/channels/qqbot/api.js

@@ -0,0 +1,199 @@
+// QQ 开放平台 HTTP interface: AccessToken management and message sending.
+// https://bot.q.qq.com/wiki/develop/api-v2/
+
+export const API_BASE = "https://api.bot.qq.com";
+// The platform documents both hosts for the token call over time; try them in
+// order, but only fall through on a network failure or a missing route.
+export const TOKEN_URLS = [
+  "https://bots.qq.com/app/getAppAccessToken",
+  "https://api.bot.qq.com/app/getAppAccessToken",
+];
+
+export class QQBotError extends Error {
+  constructor(message, { status = 0, code = 0, traceId = "" } = {}) {
+    super(message);
+    this.name = "QQBotError";
+    this.status = status;
+    this.code = Number(code) || 0;
+    this.traceId = traceId;
+  }
+}
+
+// An answer that never arrived is different from an answer that said no: the
+// first leaves delivery unknown and must not be retried automatically.
+export const isUncertain = (error) =>
+  error instanceof QQBotError ? error.uncertain === true : false;
+
+function readable(body, status) {
+  const text =
+    body?.message || body?.msg || body?.error_description || body?.error || "";
+  return String(text || `HTTP ${status}`).slice(0, 200);
+}
+
+export class QQBotApi {
+  constructor({
+    appId,
+    secret,
+    fetch: fetcher = globalThis.fetch,
+    apiBase = API_BASE,
+    tokenUrls = TOKEN_URLS,
+    now = Date.now,
+    timeoutMs = 10000,
+  }) {
+    this.appId = String(appId || "");
+    this.secret = String(secret || "");
+    this.fetch = fetcher;
+    this.apiBase = String(apiBase).replace(/\/+$/, "");
+    this.tokenUrls = tokenUrls;
+    this.now = now;
+    this.timeoutMs = timeoutMs;
+    this.cached = null;
+    this.inflight = null;
+  }
+
+  async #post(url, body) {
+    return this.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeoutMs),
+    });
+  }
+
+  async #fetchToken() {
+    let failure = null;
+    for (const url of this.tokenUrls) {
+      let response;
+      try {
+        response = await this.#post(url, {
+          appId: this.appId,
+          clientSecret: this.secret,
+        });
+      } catch (error) {
+        failure = new QQBotError("无法连接 QQ 开放平台");
+        failure.cause = error;
+        continue;
+      }
+      if (response.status === 404) {
+        failure = new QQBotError("QQ 开放平台没有找到鉴权接口", {
+          status: 404,
+        });
+        continue;
+      }
+      let body = null;
+      try {
+        body = await response.json();
+      } catch {
+        /* Reported below with the HTTP status. */
+      }
+      const token = body?.access_token;
+      if (!response.ok || !token) {
+        throw new QQBotError(
+          readable(body, response.status) || "AppID 或 AppSecret 不正确",
+          { status: response.status, code: body?.code },
+        );
+      }
+      const seconds = Number(body.expires_in);
+      return {
+        token: String(token),
+        expiresAt:
+          this.now() +
+          (Number.isFinite(seconds) && seconds > 0 ? seconds : 7200) * 1000,
+      };
+    }
+    throw failure || new QQBotError("无法获取 AccessToken");
+  }
+
+  // The token is shared by every caller and renewed a little before it
+  // expires; the platform keeps the old one valid for the last minute.
+  async token({ force = false } = {}) {
+    if (!this.appId || !this.secret)
+      throw new QQBotError("尚未填写 AppID 和 AppSecret");
+    if (!force && this.cached && this.cached.expiresAt - this.now() > 90000)
+      return this.cached.token;
+    this.inflight ||= this.#fetchToken()
+      .then((value) => {
+        this.cached = value;
+        return value;
+      })
+      .finally(() => {
+        this.inflight = null;
+      });
+    return (await this.inflight).token;
+  }
+
+  invalidate() {
+    this.cached = null;
+  }
+
+  async request(method, path, body, { retry = true } = {}) {
+    const token = await this.token();
+    let response;
+    try {
+      response = await this.fetch(this.apiBase + path, {
+        method,
+        headers: {
+          Authorization: `QQBot ${token}`,
+          "Content-Type": "application/json",
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(this.timeoutMs),
+      });
+    } catch (error) {
+      const timedOut =
+        error?.name === "TimeoutError" || error?.name === "AbortError";
+      const neverLeft =
+        /^(ENOTFOUND|ECONNREFUSED|EAI_AGAIN|ENETUNREACH|ERR_TLS|CERT_|UNABLE_TO)/.test(
+          String(error?.cause?.code || error?.code || ""),
+        );
+      const failure = new QQBotError(
+        timedOut ? "QQ 发送确认超时，不自动重发" : "无法连接 QQ 开放平台",
+      );
+      // A send that left but was never answered may have arrived. Never
+      // repeat it on our own; one that could not leave is safe to report.
+      failure.uncertain = method !== "GET" && !neverLeft;
+      failure.cause = error;
+      throw failure;
+    }
+    let data = null;
+    try {
+      data = await response.json();
+    } catch {
+      /* An empty body is fine for some calls. */
+    }
+    const traceId = response.headers?.get?.("x-tps-trace-id") || "";
+    if (response.status === 401 && retry) {
+      this.invalidate();
+      return this.request(method, path, body, { retry: false });
+    }
+    if (!response.ok)
+      throw new QQBotError(readable(data, response.status), {
+        status: response.status,
+        code: data?.code ?? data?.err_code,
+        traceId,
+      });
+    return data ?? {};
+  }
+
+  async gatewayUrl() {
+    const data = await this.request("GET", "/gateway");
+    if (!data?.url) throw new QQBotError("QQ 开放平台没有返回网关地址");
+    return String(data.url);
+  }
+
+  sendGroup(groupOpenid, body) {
+    return this.request(
+      "POST",
+      `/v2/groups/${encodeURIComponent(groupOpenid)}/messages`,
+      body,
+    );
+  }
+
+  sendUser(openid, body) {
+    return this.request(
+      "POST",
+      `/v2/users/${encodeURIComponent(openid)}/messages`,
+      body,
+    );
+  }
+}

package/server/channels/qqbot/credentials.js

@@ -0,0 +1,11 @@
+// The AppID and AppSecret of the official bot. The environment wins over what
+// was saved in the studio, the same way LLM_API_KEY does for the model key.
+export function qqbotCredentials(store, env = process.env) {
+  const saved = store.settings();
+  return {
+    appId: String(env.QQBOT_APP_ID || saved.qqbotAppId || "").trim(),
+    secret: String(env.QQBOT_APP_SECRET || saved.qqbotSecret || "").trim(),
+    appIdFromEnv: !!env.QQBOT_APP_ID,
+    secretFromEnv: !!env.QQBOT_APP_SECRET,
+  };
+}

package/server/channels/qqbot/gateway.js

@@ -0,0 +1,274 @@
+import { WebSocket } from "ws";
+
+// Opcodes of the QQ 开放平台 WebSocket gateway.
+const OP = {
+  dispatch: 0,
+  heartbeat: 1,
+  identify: 2,
+  resume: 6,
+  reconnect: 7,
+  invalidSession: 9,
+  hello: 10,
+  ack: 11,
+};
+
+// GROUP_AND_C2C_EVENT: group messages, private messages, and the events that
+// say a room switched proactive messages on or off.
+export const INTENTS = 1 << 25;
+
+const BACKOFF = [1000, 2000, 4000, 8000, 15000, 30000, 60000];
+// Close codes after which the saved session cannot be resumed.
+const FRESH = new Set([
+  4006, 4007, 4009, 4900, 4901, 4902, 4903, 4904, 4905, 4906, 4907, 4908, 4909,
+  4910, 4911, 4912, 4913,
+]);
+// Close codes that retrying will not fix: the platform has taken the bot
+// offline or refused its permissions.
+const FATAL = new Set([4914, 4915]);
+const TOKEN_REJECTED = new Set([4004]);
+
+// Keeps one connection to the gateway alive: Hello → Identify, heartbeat,
+// Resume after a short drop, a fresh session when the platform says so, and a
+// patient reconnect with backoff.
+export class QQBotGateway {
+  constructor({
+    api,
+    onDispatch,
+    onState = () => {},
+    WebSocketImpl = WebSocket,
+    now = Date.now,
+    backoff = BACKOFF,
+  }) {
+    this.backoff = backoff;
+    this.api = api;
+    this.onDispatch = onDispatch;
+    this.onState = onState;
+    this.WebSocketImpl = WebSocketImpl;
+    this.now = now;
+    this.socket = null;
+    this.sessionId = "";
+    this.seq = null;
+    this.ready = false;
+    this.attempt = 0;
+    this.stopped = true;
+    this.heartbeatTimer = null;
+    this.reconnectTimer = null;
+    this.acked = true;
+    this.generation = 0;
+  }
+
+  start() {
+    if (!this.stopped) return;
+    this.stopped = false;
+    this.attempt = 0;
+    this.#connect();
+  }
+
+  stop() {
+    this.stopped = true;
+    this.generation++;
+    clearTimeout(this.reconnectTimer);
+    clearInterval(this.heartbeatTimer);
+    this.reconnectTimer = null;
+    this.heartbeatTimer = null;
+    const socket = this.socket;
+    this.socket = null;
+    this.ready = false;
+    try {
+      socket?.removeAllListeners?.();
+      socket?.on?.("error", () => {});
+      socket?.terminate?.();
+    } catch {
+      /* Already gone. */
+    }
+  }
+
+  async #connect() {
+    const generation = ++this.generation;
+    clearTimeout(this.reconnectTimer);
+    this.onState({ state: "connecting" });
+    let url;
+    try {
+      url = await this.api.gatewayUrl();
+    } catch (error) {
+      if (generation !== this.generation || this.stopped) return;
+      this.onState({ state: "error", error: error.message });
+      return this.#later();
+    }
+    if (generation !== this.generation || this.stopped) return;
+    let socket;
+    try {
+      socket = new this.WebSocketImpl(url);
+    } catch (error) {
+      this.onState({ state: "error", error: error.message });
+      return this.#later();
+    }
+    this.socket = socket;
+    socket.on("message", (data) => {
+      if (generation === this.generation) this.#message(data, socket);
+    });
+    socket.on("error", (error) => {
+      if (generation === this.generation)
+        this.onState({ state: "error", error: error.message });
+    });
+    socket.on("close", (code) => {
+      if (generation !== this.generation) return;
+      this.#closed(Number(code) || 0);
+    });
+  }
+
+  async #identify(socket) {
+    const token = await this.api.token();
+    if (this.sessionId && this.seq != null)
+      socket.send(
+        JSON.stringify({
+          op: OP.resume,
+          d: {
+            token: `QQBot ${token}`,
+            session_id: this.sessionId,
+            seq: this.seq,
+          },
+        }),
+      );
+    else
+      socket.send(
+        JSON.stringify({
+          op: OP.identify,
+          d: {
+            token: `QQBot ${token}`,
+            intents: INTENTS,
+            shard: [0, 1],
+            properties: {},
+          },
+        }),
+      );
+  }
+
+  #message(data, socket) {
+    let payload;
+    try {
+      payload = JSON.parse(data.toString());
+    } catch {
+      return;
+    }
+    if (!payload || typeof payload !== "object") return;
+    if (Number.isInteger(payload.s)) this.seq = payload.s;
+    switch (payload.op) {
+      case OP.hello: {
+        const interval = Math.max(
+          1000,
+          Number(payload.d?.heartbeat_interval) || 40000,
+        );
+        this.acked = true;
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => {
+          if (!this.acked) {
+            // A whole interval without an answer: the line is dead.
+            try {
+              socket.terminate();
+            } catch {
+              /* Closing anyway. */
+            }
+            return;
+          }
+          this.acked = false;
+          try {
+            socket.send(JSON.stringify({ op: OP.heartbeat, d: this.seq }));
+          } catch {
+            /* The close handler reconnects. */
+          }
+        }, interval);
+        this.heartbeatTimer.unref?.();
+        this.#identify(socket).catch((error) => {
+          this.onState({ state: "error", error: error.message });
+          try {
+            socket.terminate();
+          } catch {
+            /* Reconnect handles it. */
+          }
+        });
+        break;
+      }
+      case OP.ack:
+        this.acked = true;
+        break;
+      case OP.heartbeat:
+        try {
+          socket.send(JSON.stringify({ op: OP.heartbeat, d: this.seq }));
+        } catch {
+          /* Ignored. */
+        }
+        break;
+      case OP.reconnect:
+        try {
+          socket.terminate();
+        } catch {
+          /* Ignored. */
+        }
+        break;
+      case OP.invalidSession:
+        // The saved session is no good any more: start over.
+        this.sessionId = "";
+        this.seq = null;
+        try {
+          socket.terminate();
+        } catch {
+          /* Ignored. */
+        }
+        break;
+      case OP.dispatch:
+        if (payload.t === "READY") {
+          this.sessionId = String(payload.d?.session_id || "");
+          this.ready = true;
+          this.attempt = 0;
+          this.onState({ state: "ready", user: payload.d?.user || null });
+        } else if (payload.t === "RESUMED") {
+          this.ready = true;
+          this.attempt = 0;
+          this.onState({ state: "ready", resumed: true });
+        } else {
+          try {
+            this.onDispatch(payload.t, payload.d, payload.id);
+          } catch (error) {
+            console.error(`QQ 官方机器人事件处理失败：${error.message}`);
+          }
+        }
+        break;
+      default:
+    }
+  }
+
+  #closed(code) {
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+    this.socket = null;
+    const wasReady = this.ready;
+    this.ready = false;
+    if (this.stopped) return;
+    if (FRESH.has(code)) {
+      this.sessionId = "";
+      this.seq = null;
+    }
+    if (TOKEN_REJECTED.has(code)) this.api.invalidate();
+    if (FATAL.has(code)) {
+      this.stopped = true;
+      this.onState({
+        state: "error",
+        error: `QQ 开放平台关闭了连接（${code}），请检查机器人状态与权限`,
+        fatal: true,
+      });
+      return;
+    }
+    this.onState({ state: "closed", code, wasReady });
+    this.#later();
+  }
+
+  #later() {
+    if (this.stopped) return;
+    const wait = this.backoff[Math.min(this.attempt, this.backoff.length - 1)];
+    this.attempt++;
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => this.#connect(), wait);
+    this.reconnectTimer.unref?.();
+  }
+}