@zhin.js/adapter-icqq 5.0.2 → 6.0.1

package/src/endpoint.ts

@@ -4,7 +4,7 @@
  * 不再直接依赖 @icqqjs/icqq 协议库。
  * 登录由 `icqq login` 完成，本 Endpoint 只负责连接守护进程并收发消息。
  */
-import { formatCompact, Endpoint, Message, segment, SendContent, SendOptions, type QuotedMessagePayload } from 'zhin.js';
+import { formatCompact, Endpoint, Message, segment, SendContent, SendOptions, expandInteractiveSegmentsInContent, type QuotedMessagePayload,} from 'zhin.js';
 import type {
   IcqqEndpointConfig,
   IcqqSenderInfo,
@@ -49,9 +49,19 @@ import {
   shouldRefreshListsOnMeta,
   type IcqqIpcRawEvent,
 } from "./icqq-side-events.js";
-import { enableTypingIndicator, type ICQQTypingIndicatorManager } from "./typing-indicator.js";
+import {
+  disposeIcqqLoginAssistBridge,
+  handleIcqqLoginIpcEvent,
+} from "./icqq-login-assist-bridge.js";
 import { parseIcqqGetMsgResponse } from "./get-msg.js";
 import { enrichQuotedPayloadWithForward, isForwardPlaceholderPayload } from "./forward-msg.js";
+import {
+  IcqqGuildCatalog,
+  isIcqqGuildIpcEvent,
+  normalizeIcqqGuildInboundMessage,
+  type NormalizedIcqqGuildInbound,
+} from "./icqq-guild.js";
+import type { IpcGuildMessageEventData } from "./protocol.js";
 
 export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessageEvent> {
   $connected = false;
@@ -62,6 +72,8 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
   friends = new Map<number, IpcFriendInfo>();
   /** 缓存的群列表 */
   groups = new Map<number, IpcGroupInfo>();
+  /** QQ 频道（guild）子频道缓存 */
+  readonly guildCatalog = new IcqqGuildCatalog();
 
   private subscriptions: Array<{ unsubscribe: () => Promise<void> }> = [];
   /** 事件去重：覆盖多端回流/服务端重复推送等场景 */
@@ -73,9 +85,6 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
   /** 是否已有重连循环在跑（避免多次 schedule 叠套） */
   private reconnectRunning = false;
 
-  /** Typing Indicator 管理器 */
-  $typingIndicator?: ICQQTypingIndicatorManager;
-
   get $id() {
     return this.$config.name;
   }
@@ -106,50 +115,13 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
 
     await this.rebindIpcSession();
 
-    // 根据配置自动启用 Typing Indicator
-    this.initTypingIndicator();
-
     this.logger.info(formatCompact( {
       机器人: this.$id,
       好友数: this.friends.size,
       群组数: this.groups.size,
-      思考提示: this.$typingIndicator ? '已启用' : '未启用',
     }));
   }
 
-  /**
-   * 初始化 Typing Indicator
-   * 根据配置自动启用或禁用
-   */
-  private initTypingIndicator(): void {
-    const typingConfig = this.$config.typingIndicator;
-
-    // 如果配置中明确设置为 false，则不启用
-    if (typingConfig?.enabled === false) {
-      this.logger.debug(formatCompact({
-        endpoint: this.$id,
-        typingIndicator: 'disabled_by_config',
-      }));
-      return;
-    }
-
-    // 启用 Typing Indicator
-    try {
-      this.$typingIndicator = enableTypingIndicator(this, typingConfig);
-      this.logger.debug(formatCompact({
-        endpoint: this.$id,
-        typingIndicator: 'enabled',
-        emoji: typingConfig?.defaultEmoji || '⏳',
-      }));
-    } catch (error) {
-      this.logger.warn(formatCompact({
-        endpoint: this.$id,
-        typingIndicator: 'failed',
-        error: error instanceof Error ? error.message : String(error),
-      }));
-    }
-  }
-
   /** 建立或恢复与守护进程的 IPC/RPC 会话（订阅、缓存列表） */
   private async rebindIpcSession(): Promise<void> {
     const uin = Number(this.$config.name);
@@ -261,6 +233,27 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
         this.groups.set(g.group_id, g);
       }
     }
+
+    await this.guildCatalog.syncAll(this.ipc).catch((e: unknown) => {
+      this.logger.warn(formatCompact({
+        op: "sync_guilds",
+        endpoint: this.$id,
+        ok: false,
+        error: e instanceof Error ? e.message : String(e),
+      }));
+    });
+  }
+
+  /** Console：列出 guild 子频道（含 parent.guild） */
+  getGuildChannelList(): ReturnType<IcqqGuildCatalog["getGuildChannelList"]> {
+    return this.guildCatalog.getGuildChannelList();
+  }
+
+  resolveConsoleChannelNames(
+    channelId: string,
+    guildId?: string,
+  ): { channelName?: string; parentName?: string } {
+    return this.guildCatalog.resolveConsoleChannelNames(channelId, guildId);
   }
 
   // ── 断开 ───────────────────────────────────────────────────────────
@@ -268,18 +261,13 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
   async $disconnect(): Promise<void> {
     this.intentionalDisconnect = true;
 
-    // 停止所有 Typing Indicator
-    if (this.$typingIndicator) {
-      await this.$typingIndicator.stopAll().catch(() => {});
-      this.$typingIndicator = undefined;
-    }
-
     this.ipc?.setOnRemoteDisconnect(null);
     for (const sub of this.subscriptions) {
       await sub.unsubscribe().catch(() => {});
     }
     this.subscriptions = [];
     this.inboundDeduper.clear();
+    disposeIcqqLoginAssistBridge(this.$id);
     this.ipc?.close();
     this.$connected = false;
     this.logger.info(formatCompact( { op: "disconnect", endpoint: this.$id }));
@@ -288,6 +276,28 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
   // ── 消息处理 ───────────────────────────────────────────────────────
 
   private handleEvent(event: IpcEvent): void {
+    if (event.event?.startsWith("system.login.")) {
+      handleIcqqLoginIpcEvent(this, event.event, event.data);
+      return;
+    }
+
+    if (event.event === Actions.RELOAD_GUILDS) {
+      void this.guildCatalog.syncAll(this.ipc).catch((e: unknown) => {
+        this.logger.warn(formatCompact({
+          op: "reload_guilds",
+          endpoint: this.$id,
+          ok: false,
+          error: e instanceof Error ? e.message : String(e),
+        }));
+      });
+      return;
+    }
+
+    if (isIcqqGuildIpcEvent(event.event)) {
+      this.handleGuildMessageEvent(event);
+      return;
+    }
+
     const payload = unwrapIcqqIpcEventPayload(event);
     if (!payload || typeof payload !== "object") {
       if (process.env.ICQQ_IPC_LOG_RAW === "1") {
@@ -380,6 +390,80 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
     );
   }
 
+  private handleGuildMessageEvent(event: IpcEvent): void {
+    const payload = event.data;
+    if (!payload || typeof payload !== "object") return;
+    const data = payload as IpcGuildMessageEventData & Record<string, unknown>;
+    const normalized = normalizeIcqqGuildInboundMessage(data);
+    if (!normalized) return;
+
+    this.guildCatalog.upsertFromInbound(data);
+
+    if (!this.inboundDeduper.shouldProcess(`guild:${normalized.messageId}`)) {
+      return;
+    }
+
+    void this.dispatchGuildInboundMessage(normalized);
+  }
+
+  private async dispatchGuildInboundMessage(
+    normalized: NormalizedIcqqGuildInbound,
+  ): Promise<void> {
+    const message = this.$formatGuildMessage(normalized);
+    this.adapter.emit("message.receive", message);
+    this.logger.debug(
+      `${this.$id} recv channel(${message.$channel.id}):${segment.raw(message.$content)}`,
+    );
+  }
+
+  private $formatGuildMessage(
+    normalized: NormalizedIcqqGuildInbound,
+  ): ReturnType<typeof Message.from<IpcGuildMessageEventData>> {
+    const senderInfo: IcqqSenderInfo = {
+      id: normalized.userId,
+      name: normalized.nickname,
+    };
+
+    const result = Message.from(normalized.raw, {
+      $id: normalized.messageId,
+      $adapter: "icqq" as const,
+      $endpoint: this.$config.name,
+      $sender: senderInfo,
+      $channel: {
+        id: normalized.channelId,
+        type: "channel",
+        parent: { type: "guild", id: normalized.guildId },
+      },
+      $content: normalized.content,
+      $raw: normalized.rawMessage,
+      $timestamp: normalized.timestampMs,
+      $recall: async () => {
+        await this.$recallMessage(result.$id);
+      },
+      $reply: async (
+        content: SendContent,
+        quote?: boolean | string,
+      ): Promise<string> => {
+        if (!Array.isArray(content)) content = [content];
+        if (quote) {
+          content.unshift({
+            type: "reply",
+            data: { id: typeof quote === "boolean" ? result.$id : quote },
+          });
+        }
+        return await this.adapter.sendMessage({
+          context: "icqq",
+          endpoint: this.$config.name,
+          id: normalized.channelId,
+          type: "channel",
+          parent: { type: "guild", id: normalized.guildId },
+          content,
+        });
+      },
+    });
+    return result;
+  }
+
   private handleNoticeEvent(event: IcqqIpcRawEvent): void {
     const dedupeKey = resolveSideEventDedupeKey(event, "notice");
     if (!this.inboundDeduper.shouldProcess(dedupeKey)) {
@@ -503,6 +587,9 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
       $channel: {
         id: normalized.channelId,
         type: normalized.channelType,
+        ...(normalized.channelParentGroupId
+          ? { parent: { type: 'group' as const, id: normalized.channelParentGroupId } }
+          : {}),
       },
       $content: normalized.content,
       $quote_id: quoteId,
@@ -641,21 +728,51 @@ export class IcqqEndpoint implements Endpoint<IcqqEndpointConfig, IcqqIpcMessage
 
   async $sendMessage(options: SendOptions): Promise<string> {
     const outboundMedia = resolveIcqqOutboundMediaMode(this.$config);
-    const content = materializeOutboundBase64(options.content, outboundMedia);
+    const expanded = expandInteractiveSegmentsInContent(options.content);
+    const qrcodeContent = expanded;
+    const content = materializeOutboundBase64(qrcodeContent, outboundMedia);
     const message = buildIcqqIpcMessageImpl(content);
 
     let action: string;
     let params: Record<string, unknown>;
 
     switch (options.type) {
-      case "private":
-        action = Actions.SEND_PRIVATE_MSG;
-        params = { user_id: Number(options.id), message };
+      case "private": {
+        const groupParent =
+          options.parent?.type === "group" ? options.parent.id : undefined;
+        if (groupParent) {
+          action = Actions.SEND_TEMP_MSG;
+          params = {
+            group_id: Number(groupParent),
+            user_id: Number(options.id),
+            message,
+          };
+        } else {
+          action = Actions.SEND_PRIVATE_MSG;
+          params = { user_id: Number(options.id), message };
+        }
         break;
+      }
       case "group":
         action = Actions.SEND_GROUP_MSG;
         params = { group_id: Number(options.id), message };
         break;
+      case "channel": {
+        const guildId =
+          options.parent?.type === "guild" ? options.parent.id : undefined;
+        if (!guildId) {
+          throw new Error(
+            'channel 发送需要 parent: { type: "guild", id: guild_id }',
+          );
+        }
+        action = Actions.GUILD_SEND_MSG;
+        params = {
+          guild_id: guildId,
+          channel_id: options.id,
+          message,
+        };
+        break;
+      }
       default:
         throw new Error(`不支持的频道类型: ${options.type}`);
     }

package/src/icqq-guild.ts

@@ -0,0 +1,157 @@
+/**
+ * ICQQ guild (QQ 频道) catalog sync, inbound normalize, Console channel list.
+ */
+import type { MessageSegment } from "zhin.js";
+import { Actions, type IpcGuildMessageEventData } from "./protocol.js";
+import type { IpcClient } from "./ipc-client.js";
+import { parseCqMessage } from "./cq-message.js";
+import { toCanonicalSegments } from "./segment-mapper.js";
+
+export interface IcqqGuildChannelEntry {
+  channel_id: string;
+  channel_name: string;
+  guild_id: string;
+  guild_name: string;
+}
+
+export interface NormalizedIcqqGuildInbound {
+  messageId: string;
+  channelId: string;
+  guildId: string;
+  guildName: string;
+  channelName: string;
+  userId: string;
+  nickname: string;
+  content: MessageSegment[];
+  rawMessage: string;
+  timestampMs: number;
+  raw: IpcGuildMessageEventData;
+}
+
+export class IcqqGuildCatalog {
+  private readonly channels = new Map<string, IcqqGuildChannelEntry>();
+  private readonly guilds = new Map<string, { guild_id: string; guild_name: string }>();
+
+  clear(): void {
+    this.channels.clear();
+    this.guilds.clear();
+  }
+
+  async syncAll(ipc: IpcClient): Promise<void> {
+    const listResp = await ipc.request(Actions.GUILD_LIST);
+    if (!listResp.ok) return;
+
+    const guildRows = Array.isArray(listResp.data) ? listResp.data : [];
+    for (const row of guildRows) {
+      const rec = row as Record<string, unknown>;
+      const guild_id = String(rec.guild_id ?? rec.id ?? "");
+      if (!guild_id) continue;
+      const guild_name = String(rec.guild_name ?? rec.name ?? guild_id);
+      this.guilds.set(guild_id, { guild_id, guild_name });
+
+      const chResp = await ipc.request(Actions.GUILD_CHANNELS, { guild_id });
+      if (!chResp.ok || !Array.isArray(chResp.data)) continue;
+      for (const ch of chResp.data) {
+        const chRec = ch as Record<string, unknown>;
+        const channel_id = String(chRec.channel_id ?? chRec.id ?? "");
+        if (!channel_id) continue;
+        const channel_name = String(chRec.channel_name ?? chRec.name ?? channel_id);
+        this.channels.set(channel_id, {
+          channel_id,
+          channel_name,
+          guild_id,
+          guild_name,
+        });
+      }
+    }
+  }
+
+  upsertFromInbound(data: IpcGuildMessageEventData): void {
+    const guild_id = String(data.guild_id ?? "");
+    const channel_id = String(data.channel_id ?? "");
+    if (!guild_id || !channel_id) return;
+    const guild_name = String(data.guild_name ?? guild_id);
+    const channel_name = String(data.channel_name ?? channel_id);
+    this.guilds.set(guild_id, { guild_id, guild_name });
+    this.channels.set(channel_id, {
+      channel_id,
+      channel_name,
+      guild_id,
+      guild_name,
+    });
+  }
+
+  getGuildChannelList(): Array<{
+    id: string;
+    name: string;
+    parent: { type: "guild"; id: string; name: string };
+  }> {
+    return Array.from(this.channels.values()).map((entry) => ({
+      id: entry.channel_id,
+      name: entry.channel_name,
+      parent: {
+        type: "guild" as const,
+        id: entry.guild_id,
+        name: entry.guild_name,
+      },
+    }));
+  }
+
+  resolveConsoleChannelNames(
+    channelId: string,
+    guildId?: string,
+  ): { channelName?: string; parentName?: string } {
+    const entry = this.channels.get(channelId);
+    if (entry) {
+      return { channelName: entry.channel_name, parentName: entry.guild_name };
+    }
+    if (guildId) {
+      const guild = this.guilds.get(guildId);
+      return guild ? { parentName: guild.guild_name } : {};
+    }
+    return {};
+  }
+}
+
+export function isIcqqGuildIpcEvent(eventName: string | undefined): boolean {
+  return typeof eventName === "string" && eventName.startsWith("message.guild");
+}
+
+export function normalizeIcqqGuildInboundMessage(
+  data: IpcGuildMessageEventData & Record<string, unknown>,
+): NormalizedIcqqGuildInbound | null {
+  if (data.type !== "guild") return null;
+  const guildId = String(data.guild_id ?? "");
+  const channelId = String(data.channel_id ?? "");
+  if (!guildId || !channelId) return null;
+
+  const userId = String(data.tiny_id ?? data.user_id ?? "");
+  const nickname = String(data.nickname ?? userId);
+  const rawMessage = String(data.raw_message ?? "");
+  const timestampMs =
+    typeof data.time === "number" ? data.time * 1000 : Date.now();
+  const messageId =
+    data.message_id != null && String(data.message_id) !== ""
+      ? String(data.message_id)
+      : data.seq != null
+        ? String(data.seq)
+        : `${data.time ?? 0}_${userId}_${channelId}`;
+
+  const parsed = parseCqMessage(rawMessage);
+  const canonical = toCanonicalSegments(parsed);
+  const content: MessageSegment[] = canonical.length > 0 ? canonical : [{ type: "text", data: { text: rawMessage } }];
+
+  return {
+    messageId,
+    channelId,
+    guildId,
+    guildName: String(data.guild_name ?? guildId),
+    channelName: String(data.channel_name ?? channelId),
+    userId,
+    nickname,
+    content,
+    rawMessage,
+    timestampMs,
+    raw: data,
+  };
+}

package/src/icqq-inbound.ts

@@ -3,6 +3,7 @@
  */
 import { Message, type MessageSegment, type QuotedMessagePayload } from "zhin.js";
 import { parseCqMessage } from "./cq-message.js";
+import { toCanonicalSegments } from "./segment-mapper.js";
 import { extractForwardResidFromJsonElement } from "./forward-msg.js";
 import type { GroupRole } from "./types.js";
 
@@ -30,6 +31,8 @@ export interface IcqqIpcMessageEvent extends IcqqIpcEventBase {
     user_uid?: string;
     nickname?: string;
     card?: string;
+    /** 群临时会话来源群号 */
+    group_id?: number;
     /** NT/IPC 群成员角色：owner | admin | member */
     role?: GroupRole | string;
   };
@@ -81,6 +84,8 @@ export interface NormalizedIcqqInbound {
   idSource: "message_id" | "msg_id" | "seq" | "synthetic";
   channelType: "group" | "private";
   channelId: string;
+  /** 群临时会话：来源群号 */
+  channelParentGroupId?: string;
   userId: string;
   nickname: string;
   /** 群聊时来自 IPC sender.role（私聊无） */
@@ -204,9 +209,38 @@ export function shouldSkipSelfInboundMessage(
   return Number(data.self_id) === Number(data.user_id);
 }
 
+/** 群临时会话私聊：icqq message_type=private & sub_type=group */
+export function isIcqqGroupTempPrivateMessage(data: IcqqIpcMessageEvent): boolean {
+  const messageType =
+    data.message_type ??
+    (data.type === "group" || data.type === "private" ? data.type : undefined);
+  if (messageType !== "private") return false;
+  if (data.sub_type === "group") return true;
+  const groupId = data.sender?.group_id;
+  return typeof groupId === "number" && groupId > 0;
+}
+
 export function resolveChannelFromIcqqMessage(
   data: IcqqIpcMessageEvent,
-): { channelType: "group" | "private"; channelId: string } {
+): {
+  channelType: "group" | "private";
+  channelId: string;
+  channelParentGroupId?: string;
+} {
+  if (isIcqqGroupTempPrivateMessage(data)) {
+    const groupId = data.sender?.group_id ?? data.group_id;
+    const userId = resolveIcqqInboundUserId(
+      data as unknown as Record<string, unknown>,
+    );
+    if (groupId != null && userId != null) {
+      return {
+        channelType: "private",
+        channelId: String(userId),
+        channelParentGroupId: String(groupId),
+      };
+    }
+  }
+
   const messageType =
     data.message_type ??
     (data.type === "group" || data.type === "private" ? data.type : undefined);
@@ -259,12 +293,22 @@ export function icqqElementsToSegments(
           out.push({ type: "text", data: { text: String(el.text) } });
         }
         break;
-      case "at":
+      case "at": {
+        const atId = String(el.qq ?? el.user_id ?? "");
+        const name =
+          typeof el.name === "string"
+            ? el.name
+            : typeof el.nickname === "string"
+              ? el.nickname
+              : undefined;
         out.push({
           type: "at",
-          data: { qq: String(el.qq ?? el.user_id ?? "") },
+          data: name
+            ? { qq: atId, user_id: atId, id: atId, name }
+            : { qq: atId, user_id: atId, id: atId },
         });
         break;
+      }
       case "face":
         out.push({ type: "face", data: { id: Number(el.id) } });
         break;
@@ -551,7 +595,7 @@ function mergeReplyFromRawMessage(
   const quoteFromRaw = Message.quoteIdFromContent(fromRaw);
   if (!quoteFromRaw) return content;
   return [
-    { type: "reply", data: { id: quoteFromRaw, message_id: quoteFromRaw } },
+    { type: "reply", data: { message_id: quoteFromRaw } },
     ...content.filter((s) => s.type !== "reply"),
   ];
 }
@@ -566,7 +610,7 @@ function mergeReplyFromSource(
     resolveQuoteIdFromIcqqSource(findIcqqNestedMessageSource(data));
   if (!quoteId) return content;
   return [
-    { type: "reply", data: { id: quoteId, message_id: quoteId } },
+    { type: "reply", data: { message_id: quoteId } },
     ...content.filter((s) => s.type !== "reply"),
   ];
 }
@@ -584,7 +628,7 @@ export function resolveInboundContent(
   } else {
     content = [{ type: "text", data: { text: "" } }];
   }
-  return mergeReplyFromSource(content, data);
+  return toCanonicalSegments(mergeReplyFromSource(content, data));
 }
 
 export function normalizeIcqqInboundMessage(
@@ -594,7 +638,7 @@ export function normalizeIcqqInboundMessage(
   const ext = data as IcqqIpcMessageEvent & Record<string, unknown>;
   const userIdNum = resolveIcqqInboundUserId(ext);
   if (userIdNum == null) return null;
-  const { channelType, channelId } = resolveChannelFromIcqqMessage(data);
+  const { channelType, channelId, channelParentGroupId } = resolveChannelFromIcqqMessage(data);
   const resolved = resolveIcqqInboundMessageId(data, channelId);
   const nickname =
     data.sender?.nickname ?? data.nickname ?? String(userIdNum);
@@ -608,6 +652,7 @@ export function normalizeIcqqInboundMessage(
     idSource: resolved.source,
     channelType,
     channelId,
+    channelParentGroupId,
     userId: String(userIdNum),
     nickname,
     senderRole,