src/channels/
├── index.ts                          # 模块导出入口
├── types.ts                          # 全局类型定义与转换工具函数
├── ARCHITECTURE.md                   # 本文档
│
├── core/                             # 核心编排层
│   ├── ChannelManager.ts             # 单例编排器，管理子系统生命周期
│   └── SessionManager.ts             # 用户会话管理（per-chat 隔离）
│
├── gateway/                          # 网关层：消息路由与插件管理
│   ├── ActionExecutor.ts             # 消息路由 → Action 执行 → AI 对话
│   ├── PluginManager.ts              # 插件注册、生命周期、状态推送
│   └── index.ts
│
├── agent/                            # AI Agent 集成层
│   ├── ChannelEventBus.ts            # 全局事件总线（Agent → Channel）
│   ├── ChannelMessageService.ts      # 消息发送与流回调管理
│   └── index.ts
│
├── actions/                          # Action 处理器（命令/按钮响应）
│   ├── types.ts                      # Action 类型定义与常量
│   ├── SystemActions.ts              # 会话管理、帮助、设置、Agent 切换
│   ├── PlatformActions.ts            # 配对流程（pairing.show/refresh/check）
│   ├── ChatActions.ts                # 对话操作（发送、重新生成、工具确认）
│   └── index.ts
│
├── pairing/                          # 用户授权配对子系统
│   ├── PairingService.ts             # 配对码生成、审批、过期清理
│   └── index.ts
│
├── plugins/                          # 平台插件实现
│   ├── BasePlugin.ts                 # 抽象基类，定义生命周期状态机
│   ├── index.ts
│   │
│   ├── telegram/                     # Telegram 插件
│   │   ├── TelegramPlugin.ts         # Bot 实例管理、长轮询、消息分发
│   │   ├── TelegramAdapter.ts        # 消息格式转换（Telegram ↔ Unified）
│   │   ├── TelegramKeyboards.ts      # Inline Keyboard 与 Reply Keyboard 构建
│   │   └── index.ts
│   │
│   ├── lark/                         # Lark（飞书）插件
│   │   ├── LarkPlugin.ts             # WebSocket 连接、事件去重、卡片消息
│   │   ├── LarkAdapter.ts            # 消息格式转换（Lark ↔ Unified）
│   │   ├── LarkCards.ts              # 互动卡片模板（菜单、帮助、配对等）
│   │   └── index.ts
│   │
│   └── dingtalk/                     # DingTalk（钉钉）插件
│       ├── DingTalkPlugin.ts         # Stream 连接、AI Card 流式、Token 管理
│       ├── DingTalkAdapter.ts        # 消息格式转换（DingTalk ↔ Unified）
│       ├── DingTalkCards.ts          # AI Card / ActionCard 模板
│       ├── README.md                 # DingTalk 插件说明
│       └── index.ts
│
└── utils/                            # 工具函数
    ├── credentialCrypto.ts           # 凭据 Base64 编解码
    └── index.ts

graph TB
    subgraph "IM 平台"
        TG[Telegram]
        LK[Lark / 飞书]
        DT[DingTalk / 钉钉]
    end

    subgraph "Plugin Layer 插件层"
        TP["TelegramPlugin
        grammY · Long Polling"]
        LP["LarkPlugin
        larksuiteoapi · WebSocket"]
        DP["DingTalkPlugin
        dingtalk-stream · AI Card"]
    end

    subgraph "Gateway Layer 网关层"
        PM["PluginManager
        插件注册 · 生命周期 · 状态推送"]
        AE["ActionExecutor
        授权检查 · 路由 · 流式响应"]
    end

    subgraph "Core Layer 核心层"
        CM["ChannelManager
        单例编排器"]
        SM["SessionManager
        per-chat 会话隔离"]
        PS["PairingService
        配对码管理"]
    end

    subgraph "Agent Layer AI Agent 层"
        CMS["ChannelMessageService
        消息发送 · 流回调"]
        CEB["ChannelEventBus
        全局事件总线"]
    end

    subgraph "AionUi Core"
        WM["WorkerManage
        Agent 进程管理"]
        AGT["Agent Task
        Gemini / ACP / Codex"]
        DB[("SQLite Database")]
        IPC["ipcBridge
        Renderer - Main"]
    end

    TG <--> TP
    LK <--> LP
    DT <--> DP

    TP --> PM
    LP --> PM
    DP --> PM

    PM --> AE
    AE --> SM
    AE --> PS
    AE --> CMS

    CM --> PM
    CM --> SM
    CM --> PS
    CM --> AE

    CMS --> WM
    WM --> AGT
    AGT -->|"ipcBridge + channelEventBus"| CEB
    CEB --> CMS

    SM --> DB
    PS --> DB
    PM --> IPC

ChannelManager (singleton)
├── PluginManager         -- 插件注册/启停/状态监控
├── SessionManager        -- 用户会话内存缓存 + DB 持久化
├── PairingService        -- 配对码生成/审批/定时清理
└── ActionExecutor        -- 消息路由/Action 分发/AI 对话

type PluginType = 'telegram' | 'slack' | 'discord' | 'lark' | 'dingtalk';
type PluginStatus = 'created' | 'initializing' | 'ready' | 'starting' | 'running' | 'stopping' | 'stopped' | 'error';

interface IChannelPluginConfig {
  id: string;
  type: PluginType;
  name: string;
  enabled: boolean;
  credentials?: IPluginCredentials; // 加密存储（Base64）
  config?: IPluginConfigOptions; // mode, webhookUrl, rateLimit, requireMention
  status: PluginStatus;
  lastConnected?: number;
  createdAt: number;
  updatedAt: number;
}

// 入站（平台 → 系统）
interface IUnifiedIncomingMessage {
  id: string;
  platform: PluginType;
  chatId: string;
  user: IUnifiedUser;
  content: IUnifiedMessageContent;
  timestamp: number;
  action?: IMessageAction;
  raw?: unknown;
}

// 出站（系统 → 平台）
interface IUnifiedOutgoingMessage {
  type: 'text' | 'image' | 'file' | 'buttons';
  text?: string;
  parseMode?: 'HTML' | 'MarkdownV2' | 'Markdown';
  buttons?: IActionButton[][];
  replyMarkup?: unknown;
  // ...
}

type ActionCategory = 'platform' | 'system' | 'chat';

interface IRegisteredAction {
  name: string; // e.g. 'session.new', 'pairing.show'
  category: ActionCategory;
  description: string;
  handler: ActionHandler; // (context, params?) => Promise<IActionResult>
}

type ChannelAgentType = 'gemini' | 'acp' | 'codex';

interface IChannelSession {
  id: string;
  userId: string;
  agentType: ChannelAgentType;
  conversationId?: string;
  workspace?: string;
  chatId?: string; // per-chat 隔离键（如 "user:xxx" 或 "group:xxx"）
  createdAt: number;
  lastActivity: number;
}

sequenceDiagram
    participant User as IM 用户
    participant Plugin as Platform Plugin
    participant AE as ActionExecutor
    participant SM as SessionManager
    participant PS as PairingService
    participant CMS as ChannelMessageService
    participant WM as WorkerManage
    participant Agent as Agent Task
    participant CEB as ChannelEventBus

    User->>Plugin: 发送文字消息
    Plugin->>Plugin: 转换为 IUnifiedIncomingMessage
    Plugin->>AE: messageHandler(message)

    Note over AE: 授权检查
    AE->>PS: isUserAuthorized(userId, platform)
    alt 未授权
        PS-->>AE: false
        AE->>Plugin: 显示配对码
    else 已授权
        PS-->>AE: true
        AE->>SM: getSession(userId, chatId)
        alt 无 Session
            AE->>AE: 创建 Conversation + Session
        end

        Note over AE: 发送 "⏳ Thinking..." 占位消息
        AE->>Plugin: sendMessage("⏳ Thinking...")
        Plugin-->>AE: thinkingMsgId

        AE->>CMS: sendMessage(sessionId, convId, text, onStream)
        CMS->>CMS: initialize() / 注册 EventBus 监听
        CMS->>WM: getTaskByIdRollbackBuild(convId, {yoloMode})
        CMS->>Agent: task.sendMessage({input/content, msg_id})

        loop 流式响应
            Agent->>CEB: emitAgentMessage(convId, data)
            CEB->>CMS: handleAgentMessage(event)
            CMS->>CMS: transformMessage + composeMessage
            CMS->>AE: onStream(TMessage, isInsert)
            Note over AE: 500ms 节流定时器
            AE->>Plugin: editMessage(msgId, outgoingMsg)
            Plugin->>User: 更新消息内容
        end

        Agent->>CEB: emitAgentMessage(convId, {type:'finish'})
        CEB->>CMS: stream.resolve()
        CMS-->>AE: Promise resolved

        Note over AE: 添加操作按钮
        AE->>Plugin: editMessage(lastMsgId, finalMsg + buttons)
        Plugin->>User: 显示完整回复 + 操作按钮
    end

Agent 请求确认 → Agent Task 广播 tool_group (status=Confirming)
    → ChannelEventBus → ChannelMessageService → ActionExecutor
    → 根据平台构建确认 UI（Telegram: InlineKeyboard / Lark: 互动卡片 / DingTalk: AI Card 按钮）
    → Plugin 推送给用户

用户点击按钮 → Plugin 解析回调数据
    → Telegram: confirmHandler(userId, 'telegram', callId, value)
    → Lark: extractCardAction → messageHandler → handleToolConfirm
    → DingTalk: extractCardAction → confirmHandler(userId, 'dingtalk', callId, value)
    → ChannelMessageService.confirm(conversationId, callId, value)
    → Agent Task.confirm() → Agent 继续执行

-- 插件配置（Migration v7, v10, v14 演进）
CREATE TABLE assistant_plugins (
  id TEXT PRIMARY KEY,
  type TEXT NOT NULL CHECK(type IN ('telegram','slack','discord','lark','dingtalk')),
  name TEXT NOT NULL,
  enabled INTEGER NOT NULL DEFAULT 0,
  config TEXT NOT NULL,           -- JSON: { credentials, config }
  status TEXT,
  last_connected INTEGER,
  created_at INTEGER NOT NULL,
  updated_at INTEGER NOT NULL
);

-- 授权用户（Migration v7）
CREATE TABLE assistant_users (
  id TEXT PRIMARY KEY,
  platform_user_id TEXT NOT NULL,
  platform_type TEXT NOT NULL,
  display_name TEXT,
  authorized_at INTEGER NOT NULL,
  last_active INTEGER,
  session_id TEXT,
  UNIQUE(platform_user_id, platform_type)
);

-- 用户会话（Migration v7, v14 增加 chat_id）
CREATE TABLE assistant_sessions (
  id TEXT PRIMARY KEY,
  user_id TEXT NOT NULL,
  agent_type TEXT NOT NULL CHECK(agent_type IN ('gemini','acp','codex')),
  conversation_id TEXT,
  workspace TEXT,
  chat_id TEXT,                   -- per-chat 隔离键
  created_at INTEGER NOT NULL,
  last_activity INTEGER NOT NULL,
  FOREIGN KEY (user_id) REFERENCES assistant_users(id) ON DELETE CASCADE,
  FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE SET NULL
);

-- 配对码（Migration v7）
CREATE TABLE assistant_pairing_codes (
  code TEXT PRIMARY KEY,
  platform_user_id TEXT NOT NULL,
  platform_type TEXT NOT NULL,
  display_name TEXT,
  requested_at INTEGER NOT NULL,
  expires_at INTEGER NOT NULL,
  status TEXT NOT NULL DEFAULT 'pending'
    CHECK(status IN ('pending','approved','rejected','expired'))
);

-- conversations 表扩展（Migration v12, v14）
-- source 列: 'aionui' | 'telegram' | 'lark' | 'dingtalk'
-- channel_chat_id 列: per-chat 隔离键

created → initializing → ready → starting → running → stopping → stopped
              ↓                    ↓           ↓
            error ←←←←←←←←←←←←←←←←←←←←←←←←←←←