@theowlops/channelhub 1.0.0

package/dist/channels/slack/index.js

@@ -0,0 +1,122 @@
+// src/core/adapter.ts
+import { EventEmitter } from "node:events";
+
+class BaseChannel extends EventEmitter {
+  _connected = false;
+  isConnected() {
+    return this._connected;
+  }
+  setConnected(value) {
+    const changed = this._connected !== value;
+    this._connected = value;
+    if (changed) {
+      this.emit("status", value ? "connected" : "disconnected");
+    }
+  }
+}
+
+// src/channels/slack/adapter.ts
+class SlackChannelAdapter extends BaseChannel {
+  name = "slack";
+  config;
+  apiBase = "https://slack.com/api";
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async connect() {
+    if (!this.config.botToken)
+      throw new Error("Slack botToken is required.");
+    await this.callApi("auth.test", {});
+    this.setConnected(true);
+  }
+  async disconnect() {
+    this.setConnected(false);
+  }
+  normalizeEvent(event) {
+    const msg = event.event || event;
+    if (!msg || msg.type !== "message")
+      return null;
+    if (msg.subtype === "bot_message" || msg.bot_id)
+      return null;
+    const isDm = msg.channel_type === "im" || msg.channel && msg.channel.startsWith("D");
+    return {
+      id: String(msg.client_msg_id || msg.ts),
+      channel: "slack",
+      sender: {
+        id: String(msg.user || ""),
+        isBot: Boolean(msg.bot_id)
+      },
+      chat: {
+        id: String(msg.channel),
+        type: isDm ? "dm" : "channel"
+      },
+      content: {
+        text: msg.text || "",
+        replyToId: msg.thread_ts ? String(msg.thread_ts) : undefined
+      },
+      raw: event,
+      timestamp: msg.ts ? parseFloat(msg.ts) * 1000 : Date.now()
+    };
+  }
+  async callApi(method, body) {
+    const res = await fetch(`${this.apiBase}/${method}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.botToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Slack API ${method} failed: ${res.status} ${errText}`);
+    }
+    const data = await res.json();
+    if (!data.ok) {
+      throw new Error(`Slack API ${method} error: ${data.error}`);
+    }
+    return data;
+  }
+  async sendText(chatId, text, options) {
+    const payload = {
+      channel: chatId,
+      text
+    };
+    if (options?.replyToId) {
+      payload.thread_ts = options.replyToId;
+    }
+    const res = await this.callApi("chat.postMessage", payload);
+    return {
+      messageId: String(res.ts),
+      chatId,
+      timestamp: parseFloat(res.ts) * 1000
+    };
+  }
+  async sendMedia(chatId, media, options) {
+    const payload = {
+      channel: chatId,
+      text: media.caption || "Attachment"
+    };
+    if (options?.replyToId) {
+      payload.thread_ts = options.replyToId;
+    }
+    const res = await this.callApi("chat.postMessage", payload);
+    return {
+      messageId: String(res.ts),
+      chatId,
+      timestamp: parseFloat(res.ts) * 1000
+    };
+  }
+  async addReaction(chatId, messageId, emoji) {
+    const cleanName = emoji.replace(/:/g, "");
+    await this.callApi("reactions.add", {
+      channel: chatId,
+      timestamp: messageId,
+      name: cleanName
+    });
+  }
+}
+export {
+  SlackChannelAdapter
+};

package/dist/channels/telegram/adapter.d.ts

@@ -0,0 +1,21 @@
+import { BaseChannel } from "../../core/adapter";
+import type { ChannelType, MediaPayload, SendOptions, SentMessageResult, UnifiedMessage } from "../../core/types";
+import type { TelegramAdapterConfig } from "./types";
+export declare class TelegramChannelAdapter extends BaseChannel {
+    readonly name: ChannelType;
+    private config;
+    private apiRoot;
+    private pollTimer;
+    private lastUpdateId;
+    private isPolling;
+    constructor(config: TelegramAdapterConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    normalizeUpdate(update: any): UnifiedMessage | null;
+    private callApi;
+    private startPolling;
+    private stopPolling;
+    sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
+    sendMedia(chatId: string, media: MediaPayload, options?: SendOptions): Promise<SentMessageResult>;
+    addReaction(chatId: string, messageId: string, emoji: string): Promise<void>;
+}

package/dist/channels/telegram/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./adapter";

package/dist/channels/telegram/index.js

@@ -0,0 +1,179 @@
+// src/core/adapter.ts
+import { EventEmitter } from "node:events";
+
+class BaseChannel extends EventEmitter {
+  _connected = false;
+  isConnected() {
+    return this._connected;
+  }
+  setConnected(value) {
+    const changed = this._connected !== value;
+    this._connected = value;
+    if (changed) {
+      this.emit("status", value ? "connected" : "disconnected");
+    }
+  }
+}
+
+// src/channels/telegram/adapter.ts
+class TelegramChannelAdapter extends BaseChannel {
+  name = "telegram";
+  config;
+  apiRoot;
+  pollTimer = null;
+  lastUpdateId = 0;
+  isPolling = false;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.apiRoot = config.apiRoot || "https://api.telegram.org";
+  }
+  async connect() {
+    if (!this.config.botToken) {
+      throw new Error("Telegram botToken is required.");
+    }
+    this.setConnected(true);
+    if (this.config.autoStart !== false) {
+      this.startPolling();
+    }
+  }
+  async disconnect() {
+    this.stopPolling();
+    this.setConnected(false);
+  }
+  normalizeUpdate(update) {
+    if (!update)
+      return null;
+    const msg = update.message || update.edited_message || update.channel_post;
+    if (!msg)
+      return null;
+    const chatType = msg.chat.type === "private" ? "dm" : msg.chat.type === "channel" ? "channel" : "group";
+    const senderName = [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(" ");
+    return {
+      id: String(msg.message_id),
+      channel: "telegram",
+      sender: {
+        id: String(msg.from?.id ?? ""),
+        name: senderName || undefined,
+        username: msg.from?.username,
+        isBot: Boolean(msg.from?.is_bot)
+      },
+      chat: {
+        id: String(msg.chat.id),
+        type: chatType,
+        title: msg.chat.title
+      },
+      content: {
+        text: msg.text || msg.caption || "",
+        replyToId: msg.reply_to_message?.message_id ? String(msg.reply_to_message.message_id) : undefined
+      },
+      raw: update,
+      timestamp: (msg.date || Math.floor(Date.now() / 1000)) * 1000
+    };
+  }
+  async callApi(method, body) {
+    const url = `${this.apiRoot}/bot${this.config.botToken}/${method}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Telegram API ${method} failed: ${res.status} ${errText}`);
+    }
+    const data = await res.json();
+    if (!data.ok) {
+      throw new Error(`Telegram API ${method} error: ${data.description}`);
+    }
+    return data.result;
+  }
+  startPolling() {
+    if (this.isPolling)
+      return;
+    this.isPolling = true;
+    const interval = this.config.pollIntervalMs || 1000;
+    const poll = async () => {
+      if (!this.isPolling)
+        return;
+      try {
+        const updates = await this.callApi("getUpdates", {
+          offset: this.lastUpdateId + 1,
+          timeout: 10
+        });
+        if (Array.isArray(updates)) {
+          for (const u of updates) {
+            this.lastUpdateId = Math.max(this.lastUpdateId, u.update_id);
+            const unified = this.normalizeUpdate(u);
+            if (unified) {
+              this.emit("message", unified);
+            }
+          }
+        }
+      } catch (err) {
+        this.emit("error", err);
+      } finally {
+        if (this.isPolling) {
+          this.pollTimer = setTimeout(poll, interval);
+        }
+      }
+    };
+    poll();
+  }
+  stopPolling() {
+    this.isPolling = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  async sendText(chatId, text, options) {
+    const payload = {
+      chat_id: chatId,
+      text
+    };
+    if (options?.replyToId) {
+      payload.reply_to_message_id = Number(options.replyToId);
+    }
+    const res = await this.callApi("sendMessage", payload);
+    return {
+      messageId: String(res.message_id),
+      chatId,
+      timestamp: res.date * 1000
+    };
+  }
+  async sendMedia(chatId, media, options) {
+    const method = media.type === "image" ? "sendPhoto" : media.type === "video" ? "sendVideo" : "sendDocument";
+    const payload = {
+      chat_id: chatId,
+      caption: media.caption
+    };
+    if (typeof media.source === "string") {
+      if (media.type === "image")
+        payload.photo = media.source;
+      else if (media.type === "video")
+        payload.video = media.source;
+      else
+        payload.document = media.source;
+    }
+    if (options?.replyToId) {
+      payload.reply_to_message_id = Number(options.replyToId);
+    }
+    const res = await this.callApi(method, payload);
+    return {
+      messageId: String(res.message_id),
+      chatId,
+      timestamp: (res.date || Date.now()) * 1000
+    };
+  }
+  async addReaction(chatId, messageId, emoji) {
+    await this.callApi("setMessageReaction", {
+      chat_id: chatId,
+      message_id: Number(messageId),
+      reaction: [{ type: "emoji", emoji }]
+    });
+  }
+}
+export {
+  TelegramChannelAdapter
+};

package/dist/channels/telegram/types.d.ts

@@ -0,0 +1,6 @@
+export interface TelegramAdapterConfig {
+    botToken: string;
+    apiRoot?: string;
+    autoStart?: boolean;
+    pollIntervalMs?: number;
+}

package/dist/channels/zalo/adapter.d.ts

@@ -0,0 +1,22 @@
+import { BaseChannel } from "../../core/adapter";
+import type { ChannelType, MediaPayload, SendOptions, SentMessageResult } from "../../core/types";
+export interface ZaloAdapterConfig {
+    api?: any;
+    credentialsPath?: string;
+    ownId?: string;
+    defaultIsGroup?: boolean;
+}
+export declare class ZaloChannelAdapter extends BaseChannel {
+    readonly name: ChannelType;
+    private api;
+    private ownId?;
+    private config;
+    constructor(config?: ZaloAdapterConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private setupEventListener;
+    private normalizeMessage;
+    sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
+    sendMedia(chatId: string, media: MediaPayload, _options?: SendOptions): Promise<SentMessageResult>;
+    addReaction(chatId: string, messageId: string, emoji: string): Promise<void>;
+}

package/dist/channels/zalo/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./adapter";
+export { ZaloPersonalBot } from "../../personal/client";
+export { ZaloOABot } from "../../oa/client";
+export { initPersonalBot } from "../../personal/index";
+export { initOABot } from "../../oa/index";