自定义频道扩展

extensions/my-channel/
├── package.json
├── index.ts          # 插件入口
└── src/
    ├── channel.ts    # 频道实现
    └── runtime.ts    # 运行时设置

export const myChannelPlugin: ChannelPlugin = {
  // 必需方法...
  name: "my-channel",
  init: async (config) => { /* ... */ },
  sendMessage: async (context, message) => { /* ... */ },
  onMessage: async (context, handler) => { /* ... */ },
  cleanup: async (context) => { /* ... */ },
  
  // 可选方法
  
  // 编辑已发送的消息
  async editMessage(context, messageId, newContent) {
    await context.client.edit(messageId, newContent);
  },
  
  // 删除消息
  async deleteMessage(context, messageId) {
    await context.client.delete(messageId);
  },
  
  // 添加表情反应
  async addReaction(context, messageId, emoji) {
    await context.client.react(messageId, emoji);
  },
  
  // 处理附件
  async uploadAttachment(context, file) {
    return await context.client.upload(file);
  },
  
  // 获取频道信息
  async getChannelInfo(context, channelId) {
    return await context.client.getChannel(channelId);
  },
};

interface OutgoingMessage {
  channelId: string;
  text: string;
  attachments?: Array<{
    url: string;
    filename?: string;
    mimeType?: string;
  }>;
  replyTo?: string;  // 回复特定消息
  metadata?: Record<string, unknown>;
}

interface IncomingMessage {
  id: string;
  text: string;
  author: {
    id: string;
    username: string;
    displayName?: string;
  };
  channelId: string;
  timestamp: number;
  attachments?: Array<{
    url: string;
    filename?: string;
    mimeType?: string;
    size?: number;
  }>;
  replyTo?: string;
  metadata?: Record<string, unknown>;
}

import { Type } from "@sinclair/typebox";

const MyChannelConfigSchema = Type.Object({
  apiKey: Type.String({ description: "API Key" }),
  serverUrl: Type.Optional(Type.String({ description: "Server URL" })),
  enableWebhooks: Type.Optional(Type.Boolean({ description: "Enable webhooks" })),
});

const myChannelConfigSchema = {
  parse(value: unknown) {
    return MyChannelConfigSchema.parse(value);
  },
  uiHints: {
    apiKey: { label: "API Key", sensitive: true },
    serverUrl: { label: "Server URL", placeholder: "https://api.example.com" },
    enableWebhooks: { label: "Enable Webhooks", advanced: true },
  },
};

const plugin = {
  id: "my-channel",
  name: "My Channel",
  configSchema: myChannelConfigSchema,
  // ...
};

export const myChannelPlugin: ChannelPlugin = {
  // ...
  
  async sendMessage(context, message) {
    try {
      await context.client.send(message);
    } catch (err) {
      if (err.code === "RATE_LIMIT") {
        // 等待并重试
        await sleep(err.retryAfter);
        return await this.sendMessage(context, message);
      }
      
      if (err.code === "CHANNEL_NOT_FOUND") {
        throw new Error(`Channel ${message.channelId} not found`);
      }
      
      // 记录并抛出未知错误
      context.logger.error("Send message failed:", err);
      throw err;
    }
  },
  
  async onMessage(context, handler) {
    context.client.on("message", async (msg) => {
      try {
        await handler(msg);
      } catch (err) {
        context.logger.error("Message handler failed:", err);
      }
    });
    
    context.client.on("error", (err) => {
      context.logger.error("Client error:", err);
      // 尝试重新连接
      void this.reconnect(context);
    });
  },
};

export const myChannelPlugin: ChannelPlugin = {
  // ...
  
  async uploadAttachment(context, file) {
    const { client } = context;
    
    // 检查文件大小
    if (file.size > 10 * 1024 * 1024) {
      throw new Error("File too large (max 10MB)");
    }
    
    // 检查文件类型
    const allowedTypes = ["image/jpeg", "image/png", "image/gif", "video/mp4"];
    if (!allowedTypes.includes(file.mimeType)) {
      throw new Error(`Unsupported file type: ${file.mimeType}`);
    }
    
    // 上传文件
    const url = await client.upload(file.data, {
      filename: file.filename,
      mimeType: file.mimeType,
    });
    
    return { url, filename: file.filename, mimeType: file.mimeType };
  },
  
  async sendMessage(context, message) {
    const { client } = context;
    
    // 处理附件
    const attachments = [];
    if (message.attachments) {
      for (const attachment of message.attachments) {
        if (attachment.url.startsWith("http")) {
          // 已经是 URL,直接使用
          attachments.push(attachment);
        } else {
          // 本地文件,需要上传
          const uploaded = await this.uploadAttachment(context, {
            data: await readFile(attachment.url),
            filename: attachment.filename,
            mimeType: attachment.mimeType,
          });
          attachments.push(uploaded);
        }
      }
    }
    
    // 发送消息
    await client.send({
      channelId: message.channelId,
      text: message.text,
      attachments,
    });
  },
};

export const myChannelPlugin: ChannelPlugin = {
  // ...
  
  async init(config) {
    const client = await connectToMyChannel(config);
    
    // 设置心跳
    const heartbeat = setInterval(() => {
      client.ping().catch((err) => {
        console.error("Heartbeat failed:", err);
      });
    }, 30000);
    
    // 监听断线
    client.on("disconnect", async () => {
      console.log("Disconnected, attempting to reconnect...");
      await this.reconnect({ client, heartbeat, config });
    });
    
    return { client, heartbeat, config };
  },
  
  async reconnect(context) {
    const { config } = context;
    let retries = 0;
    const maxRetries = 5;
    
    while (retries < maxRetries) {
      try {
        const client = await connectToMyChannel(config);
        context.client = client;
        console.log("Reconnected successfully");
        return;
      } catch (err) {
        retries++;
        console.error(`Reconnect attempt ${retries} failed:`, err);
        await sleep(1000 * Math.pow(2, retries)); // 指数退避
      }
    }
    
    throw new Error("Failed to reconnect after max retries");
  },
  
  async cleanup(context) {
    const { client, heartbeat } = context;
    clearInterval(heartbeat);
    await client.disconnect();
  },
};