@gakr-gakr/qqbot 0.1.0

package/src/engine/gateway/gateway-connection.ts

@@ -0,0 +1,356 @@
+import WebSocket from "ws";
+import type { EngineAdapters } from "../adapter/index.js";
+import {
+  trySlashCommand,
+  type SlashCommandHandlerContext,
+} from "../commands/slash-command-handler.js";
+import {
+  clearTokenCache,
+  getAccessToken,
+  getGatewayUrl,
+  getPluginUserAgent,
+  startBackgroundTokenRefresh,
+  stopBackgroundTokenRefresh,
+} from "../messaging/sender.js";
+import { flushRefIndex } from "../ref/store.js";
+import { flushKnownUsers } from "../session/known-users.js";
+import { clearSession, loadSession, saveSession } from "../session/session-store.js";
+import type { InteractionEvent } from "../types.js";
+import { decodeGatewayMessageData } from "./codec.js";
+import { FULL_INTENTS, RATE_LIMIT_DELAY, GatewayOp } from "./constants.js";
+import { dispatchEvent } from "./event-dispatcher.js";
+import { createMessageQueue, type QueuedMessage } from "./message-queue.js";
+import { ReconnectState } from "./reconnect.js";
+import type { GatewayAccount, EngineLogger, GatewayPluginRuntime, WSPayload } from "./types.js";
+import { createQQWSClient } from "./ws-client.js";
+
+interface GatewayConnectionContext {
+  account: GatewayAccount;
+  abortSignal: AbortSignal;
+  cfg: unknown;
+  log?: EngineLogger;
+  runtime: GatewayPluginRuntime;
+  adapters: EngineAdapters;
+  onReady?: (data: unknown) => void;
+  onResumed?: (data: unknown) => void;
+  onError?: (error: Error) => void;
+  handleMessage: (event: QueuedMessage) => Promise<void>;
+  onInteraction?: (event: InteractionEvent) => void;
+}
+
+export class GatewayConnection {
+  private isAborted = false;
+  private currentWs: WebSocket | null = null;
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+  private sessionId: string | null = null;
+  private lastSeq: number | null = null;
+  private isConnecting = false;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private shouldRefreshToken = false;
+
+  private readonly reconnect: ReconnectState;
+  private readonly msgQueue;
+  private readonly ctx: GatewayConnectionContext;
+
+  constructor(ctx: GatewayConnectionContext) {
+    this.ctx = ctx;
+    this.reconnect = new ReconnectState(ctx.account.accountId, ctx.log);
+    this.msgQueue = createMessageQueue({
+      accountId: ctx.account.accountId,
+      log: ctx.log,
+      isAborted: () => this.isAborted,
+    });
+  }
+
+  async start(): Promise<void> {
+    this.restoreSession();
+    this.registerAbortHandler();
+    await this.connect();
+    return new Promise<void>((resolve) => {
+      this.ctx.abortSignal.addEventListener("abort", () => resolve());
+    });
+  }
+
+  private restoreSession(): void {
+    const { account, log } = this.ctx;
+    const saved = loadSession(account.accountId, account.appId);
+    if (saved) {
+      this.sessionId = saved.sessionId;
+      this.lastSeq = saved.lastSeq;
+      log?.info(`Restored session: sessionId=${this.sessionId}, lastSeq=${this.lastSeq}`);
+    }
+  }
+
+  private saveCurrentSession(): void {
+    const { account } = this.ctx;
+    if (!this.sessionId) {
+      return;
+    }
+    saveSession({
+      sessionId: this.sessionId,
+      lastSeq: this.lastSeq,
+      lastConnectedAt: Date.now(),
+      intentLevelIndex: 0,
+      accountId: account.accountId,
+      savedAt: Date.now(),
+      appId: account.appId,
+    });
+  }
+
+  private registerAbortHandler(): void {
+    const { account, abortSignal, log: _log } = this.ctx;
+    abortSignal.addEventListener("abort", () => {
+      this.isAborted = true;
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      this.cleanup();
+      stopBackgroundTokenRefresh(account.appId);
+      flushKnownUsers();
+      flushRefIndex();
+    });
+  }
+
+  private cleanup(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (
+      this.currentWs &&
+      (this.currentWs.readyState === WebSocket.OPEN ||
+        this.currentWs.readyState === WebSocket.CONNECTING)
+    ) {
+      this.currentWs.close();
+    }
+    this.currentWs = null;
+  }
+
+  private scheduleReconnect(customDelay?: number): void {
+    const { account: _account, log } = this.ctx;
+    if (this.isAborted || this.reconnect.isExhausted()) {
+      log?.error(`Max reconnect attempts reached or aborted`);
+      return;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const delay = this.reconnect.getNextDelay(customDelay);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.isAborted) {
+        void this.connect();
+      }
+    }, delay);
+  }
+
+  private async connect(): Promise<void> {
+    const { account, log } = this.ctx;
+
+    if (this.isConnecting) {
+      log?.debug?.(`Already connecting, skip`);
+      return;
+    }
+    this.isConnecting = true;
+
+    try {
+      this.cleanup();
+      if (this.shouldRefreshToken) {
+        log?.debug?.(`Refreshing token...`);
+        clearTokenCache(account.appId);
+        this.shouldRefreshToken = false;
+      }
+
+      const accessToken = await getAccessToken(account.appId, account.clientSecret);
+      log?.info(`✅ Access token obtained successfully`);
+      const gatewayUrl = await getGatewayUrl(accessToken, account.appId);
+      log?.info(`Connecting to ${gatewayUrl}`);
+      const ws = await createQQWSClient({
+        gatewayUrl,
+        userAgent: getPluginUserAgent(),
+      });
+      this.currentWs = ws;
+
+      const slashCtx: SlashCommandHandlerContext = {
+        account,
+        cfg: this.ctx.cfg,
+        log,
+        getMessagePeerId: (msg) => this.msgQueue.getMessagePeerId(msg),
+        getQueueSnapshot: (peerId) => this.msgQueue.getSnapshot(peerId),
+        resolveCommandAuthorized: (params) =>
+          this.ctx.adapters.access.resolveSlashCommandAuthorization({
+            cfg: this.ctx.cfg,
+            accountId: account.accountId,
+            ...params,
+          }),
+      };
+
+      const trySlashCommandOrEnqueue = async (msg: QueuedMessage): Promise<void> => {
+        const result = await trySlashCommand(msg, slashCtx);
+        if (result === "enqueue") {
+          this.msgQueue.enqueue(msg);
+        } else if (result === "urgent") {
+          const peerId = this.msgQueue.getMessagePeerId(msg);
+          this.msgQueue.clearUserQueue(peerId);
+          this.msgQueue.executeImmediate(msg);
+        }
+        // "handled" — command executed, nothing to queue.
+      };
+
+      // ---- WebSocket: open ----
+      ws.on("open", () => {
+        log?.info(`WebSocket connected`);
+        this.isConnecting = false;
+        this.reconnect.onConnected();
+        this.msgQueue.startProcessor(this.ctx.handleMessage);
+        startBackgroundTokenRefresh(account.appId, account.clientSecret, { log });
+      });
+
+      // ---- WebSocket: message ----
+      ws.on("message", async (data) => {
+        try {
+          const rawData = decodeGatewayMessageData(data);
+          const payload = JSON.parse(rawData) as WSPayload;
+          const { op, d, s, t } = payload;
+
+          if (s) {
+            this.lastSeq = s;
+            this.saveCurrentSession();
+          }
+
+          switch (op) {
+            case GatewayOp.HELLO:
+              this.handleHello(ws, d, accessToken);
+              break;
+
+            case GatewayOp.DISPATCH: {
+              log?.debug?.(`Dispatch event: t=${t}, d=${JSON.stringify(d)}`);
+              const result = dispatchEvent(t ?? "", d, account.accountId, log);
+              if (result.action === "ready") {
+                this.sessionId = result.sessionId;
+                this.saveCurrentSession();
+                this.ctx.onReady?.(result.data);
+              } else if (result.action === "resumed") {
+                (this.ctx.onResumed ?? this.ctx.onReady)?.(result.data);
+                this.saveCurrentSession();
+              } else if (result.action === "interaction") {
+                this.ctx.onInteraction?.(result.event);
+              } else if (result.action === "message") {
+                void trySlashCommandOrEnqueue(result.msg);
+              }
+              break;
+            }
+
+            case GatewayOp.HEARTBEAT_ACK:
+              break;
+
+            case GatewayOp.RECONNECT:
+              this.cleanup();
+              this.scheduleReconnect();
+              break;
+
+            case GatewayOp.INVALID_SESSION: {
+              const canResume = d as boolean;
+              if (!canResume) {
+                this.sessionId = null;
+                this.lastSeq = null;
+                clearSession(account.accountId);
+                this.shouldRefreshToken = true;
+              }
+              this.cleanup();
+              this.scheduleReconnect(3000);
+              break;
+            }
+          }
+        } catch (err) {
+          log?.error(`Message parse error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      });
+
+      // ---- WebSocket: close ----
+      ws.on("close", (code, reason) => {
+        log?.info(`WebSocket closed: ${code} ${reason.toString()}`);
+        this.isConnecting = false;
+        this.handleClose(code);
+      });
+
+      // ---- WebSocket: error ----
+      ws.on("error", (err) => {
+        log?.error(`WebSocket error: ${err.message}`);
+        this.ctx.onError?.(err);
+      });
+    } catch (err) {
+      this.isConnecting = false;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log?.error(`Connection failed: ${errMsg}`);
+      if (errMsg.includes("Too many requests") || errMsg.includes("100001")) {
+        this.scheduleReconnect(RATE_LIMIT_DELAY);
+      } else {
+        this.scheduleReconnect();
+      }
+    }
+  }
+
+  // ============ Protocol handlers ============
+
+  private handleHello(ws: WebSocket, d: unknown, accessToken: string): void {
+    if (this.sessionId && this.lastSeq !== null) {
+      ws.send(
+        JSON.stringify({
+          op: GatewayOp.RESUME,
+          d: {
+            token: `QQBot ${accessToken}`,
+            session_id: this.sessionId,
+            seq: this.lastSeq,
+          },
+        }),
+      );
+    } else {
+      ws.send(
+        JSON.stringify({
+          op: GatewayOp.IDENTIFY,
+          d: {
+            token: `QQBot ${accessToken}`,
+            intents: FULL_INTENTS,
+            shard: [0, 1],
+          },
+        }),
+      );
+    }
+
+    const interval = (d as { heartbeat_interval: number }).heartbeat_interval;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+    }
+    this.heartbeatInterval = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ op: GatewayOp.HEARTBEAT, d: this.lastSeq }));
+      }
+    }, interval);
+  }
+
+  private handleClose(code: number): void {
+    const { account } = this.ctx;
+    const action = this.reconnect.handleClose(code, this.isAborted);
+
+    if (action.clearSession) {
+      this.sessionId = null;
+      this.lastSeq = null;
+      clearSession(account.accountId);
+    }
+    if (action.refreshToken) {
+      this.shouldRefreshToken = true;
+    }
+
+    this.cleanup();
+
+    if (action.fatal) {
+      return;
+    }
+    if (action.shouldReconnect) {
+      this.scheduleReconnect(action.reconnectDelay);
+    }
+  }
+}

package/src/engine/gateway/gateway.ts

@@ -0,0 +1,267 @@
+import path from "node:path";
+import { initCommands } from "../commands/slash-commands-impl.js";
+import { createNodeSessionStoreReader } from "../group/activation.js";
+import type { HistoryEntry } from "../group/history.js";
+import { setOutboundAudioPort } from "../messaging/outbound.js";
+import {
+  clearTokenCache,
+  getAccessToken,
+  initApiConfig,
+  onMessageSent,
+  sendInputNotify as senderSendInputNotify,
+  createRawInputNotifyFn,
+  accountToCreds,
+} from "../messaging/sender.js";
+import { setRefIndex } from "../ref/store.js";
+import { runDiagnostics } from "../utils/diagnostics.js";
+import { runWithRequestContext } from "../utils/request-context.js";
+import { createActiveCfgProvider } from "./active-cfg.js";
+import { GatewayConnection } from "./gateway-connection.js";
+import { buildInboundContext, clearGroupPendingHistory } from "./inbound-pipeline.js";
+import { createInteractionHandler } from "./interaction-handler.js";
+import type { QueuedMessage } from "./message-queue.js";
+import { dispatchOutbound } from "./outbound-dispatch.js";
+import type {
+  CoreGatewayContext,
+  GatewayAccount,
+  EngineLogger,
+  RefAttachmentSummary,
+} from "./types.js";
+import { TypingKeepAlive, TYPING_INPUT_SECOND } from "./typing-keepalive.js";
+
+export type { CoreGatewayContext } from "./types.js";
+
+export async function startGateway(ctx: CoreGatewayContext): Promise<void> {
+  const { account, log, runtime, adapters } = ctx;
+
+  setOutboundAudioPort(adapters.outboundAudio);
+  initCommands(adapters.commands);
+
+  if (!account.appId || !account.clientSecret) {
+    throw new Error("QQBot not configured (missing appId or clientSecret)");
+  }
+
+  const diag = await runDiagnostics();
+  if (diag.warnings.length > 0) {
+    for (const w of diag.warnings) {
+      log?.info(w);
+    }
+  }
+
+  initApiConfig(account.appId, { markdownSupport: account.markdownSupport });
+  log?.debug?.(`API config: markdownSupport=${account.markdownSupport}`);
+
+  onMessageSent(account.appId, (refIdx, meta) => {
+    log?.info(
+      `onMessageSent called: refIdx=${refIdx}, mediaType=${meta.mediaType}, ttsText=${meta.ttsText?.slice(0, 30)}`,
+    );
+    const attachments: RefAttachmentSummary[] = [];
+    if (meta.mediaType) {
+      const localPath = meta.mediaLocalPath;
+      const filename = localPath ? path.basename(localPath) : undefined;
+      const attachment: RefAttachmentSummary = {
+        type: meta.mediaType,
+        ...(localPath ? { localPath } : {}),
+        ...(filename ? { filename } : {}),
+        ...(meta.mediaUrl ? { url: meta.mediaUrl } : {}),
+      };
+      if (meta.mediaType === "voice" && meta.ttsText) {
+        attachment.transcript = meta.ttsText;
+        attachment.transcriptSource = "tts";
+      }
+      attachments.push(attachment);
+    }
+    setRefIndex(refIdx, {
+      content: meta.text ?? "",
+      senderId: account.accountId,
+      senderName: account.accountId,
+      timestamp: Date.now(),
+      isBot: true,
+      ...(attachments.length > 0 ? { attachments } : {}),
+    });
+  });
+
+  const groupOpts = {
+    enabled: ctx.group?.enabled ?? true,
+    allowTextCommands: ctx.group?.allowTextCommands,
+    isControlCommand: ctx.group?.isControlCommand,
+    resolveIntroHint: ctx.group?.resolveIntroHint,
+    sessionStoreReader: ctx.group?.sessionStoreReader,
+  };
+  const groupChatEnabled = groupOpts.enabled;
+  const groupHistories: Map<string, HistoryEntry[]> | undefined = groupChatEnabled
+    ? new Map()
+    : undefined;
+  const sessionStoreReader = groupChatEnabled
+    ? (groupOpts.sessionStoreReader ?? createNodeSessionStoreReader())
+    : undefined;
+
+  // Live config provider: per-inbound lookup so binding edits applied
+  // through the CLI take effect without a gateway restart (#69546).
+  const activeCfgProvider = createActiveCfgProvider({ fallback: ctx.cfg });
+
+  // ---- 7. Message handler ----
+  const handleMessage = async (event: QueuedMessage): Promise<void> => {
+    log?.info(`Processing message from ${event.senderId}: ${event.content}`, {
+      accountId: account.accountId,
+      messageId: event.messageId,
+      senderId: event.senderId,
+      type: event.type,
+      groupOpenid: event.groupOpenid,
+    });
+
+    runtime.channel.activity.record({
+      channel: "qqbot",
+      accountId: account.accountId,
+      direction: "inbound",
+    });
+
+    const activeCfg = activeCfgProvider.getActiveCfg();
+
+    const inbound = await buildInboundContext(event, {
+      account,
+      cfg: activeCfg,
+      log,
+      runtime,
+      startTyping: (ev) => startTypingForEvent(ev, account, log),
+      groupHistories,
+      sessionStoreReader,
+      allowTextCommands: groupOpts.allowTextCommands,
+      isControlCommand: groupOpts.isControlCommand,
+      resolveGroupIntroHint: groupOpts.resolveIntroHint,
+      adapters,
+    });
+
+    if (inbound.blocked) {
+      log?.info(`Dropped inbound qqbot message: ${inbound.blockReason ?? "blocked by allowFrom"}`, {
+        accountId: account.accountId,
+        messageId: event.messageId,
+        blockReason: inbound.blockReason,
+      });
+      inbound.typing.keepAlive?.stop();
+      return;
+    }
+
+    if (inbound.skipped) {
+      log?.info(
+        `Skipped group inbound: reason=${inbound.skipReason ?? "unknown"} group=${event.groupOpenid ?? ""}`,
+        {
+          accountId: account.accountId,
+          messageId: event.messageId,
+          skipReason: inbound.skipReason,
+          groupOpenid: event.groupOpenid,
+        },
+      );
+      inbound.typing.keepAlive?.stop();
+      return;
+    }
+
+    try {
+      await runWithRequestContext(
+        {
+          accountId: account.accountId,
+          target: inbound.qualifiedTarget,
+          targetId: inbound.peerId,
+          chatType: event.type,
+        },
+        () => dispatchOutbound(inbound, { runtime, cfg: activeCfg, account, log }),
+      );
+    } catch (err) {
+      log?.error(`Message processing failed: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      inbound.typing.keepAlive?.stop();
+      if (event.type === "group" && event.groupOpenid && inbound.group) {
+        clearGroupPendingHistory({
+          historyMap: groupHistories,
+          groupOpenid: event.groupOpenid,
+          historyLimit: inbound.group.historyLimit,
+          historyPort: adapters.history,
+        });
+      }
+    }
+  };
+
+  const handleInteraction = createInteractionHandler(account, ctx.runtime, log, {
+    getActiveCfg: () => activeCfgProvider.getActiveCfg(),
+  });
+
+  const connection = new GatewayConnection({
+    account,
+    abortSignal: ctx.abortSignal,
+    cfg: ctx.cfg,
+    log,
+    runtime,
+    adapters,
+    onReady: ctx.onReady,
+    onResumed: ctx.onResumed,
+    onError: ctx.onError,
+    onInteraction: handleInteraction,
+    handleMessage,
+  });
+
+  await connection.start();
+}
+
+// ============ Typing helper ============
+
+/**
+ * Start typing indicator for a C2C event.
+ * Returns the refIdx from InputNotify and a TypingKeepAlive handle.
+ */
+async function startTypingForEvent(
+  event: QueuedMessage,
+  account: GatewayAccount,
+  log?: EngineLogger,
+): Promise<{ refIdx?: string; keepAlive: TypingKeepAlive | null }> {
+  const isC2C = event.type === "c2c" || event.type === "dm";
+  if (!isC2C) {
+    return { keepAlive: null };
+  }
+  try {
+    const creds = accountToCreds(account);
+    const rawNotifyFn = createRawInputNotifyFn(account.appId);
+    try {
+      const resp = await senderSendInputNotify({
+        openid: event.senderId,
+        creds,
+        msgId: event.messageId,
+        inputSecond: TYPING_INPUT_SECOND,
+      });
+      const keepAlive = new TypingKeepAlive(
+        () => getAccessToken(account.appId, account.clientSecret),
+        () => clearTokenCache(account.appId),
+        rawNotifyFn,
+        event.senderId,
+        event.messageId,
+        log,
+      );
+      keepAlive.start();
+      return { refIdx: resp.refIdx, keepAlive };
+    } catch (notifyErr) {
+      const errMsg = String(notifyErr);
+      if (errMsg.includes("token") || errMsg.includes("401") || errMsg.includes("11244")) {
+        clearTokenCache(account.appId);
+        const resp = await senderSendInputNotify({
+          openid: event.senderId,
+          creds,
+          msgId: event.messageId,
+          inputSecond: TYPING_INPUT_SECOND,
+        });
+        const keepAlive = new TypingKeepAlive(
+          () => getAccessToken(account.appId, account.clientSecret),
+          () => clearTokenCache(account.appId),
+          rawNotifyFn,
+          event.senderId,
+          event.messageId,
+          log,
+        );
+        keepAlive.start();
+        return { refIdx: resp.refIdx, keepAlive };
+      }
+      throw notifyErr;
+    }
+  } catch (err) {
+    log?.error(`sendInputNotify error: ${err instanceof Error ? err.message : String(err)}`);
+    return { keepAlive: null };
+  }
+}