@theowlops/channelhub 1.0.0

package/dist/commands/modules/general.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../types.js";
+export declare const heartCommand: Command;
+export declare const hahaCommand: Command;
+export declare const pingCommand: Command;

package/dist/commands/modules/group.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../types.js";
+export declare const kickCommand: Command;
+export declare const renameCommand: Command;
+export declare const groupInfoCommand: Command;

package/dist/commands/modules/reaction.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../types.js";
+import { Reactions } from "zca-js";
+export declare const EMOJI_TO_REACTION: Record<string, Reactions | string>;
+export declare const reactCommand: Command;

package/dist/commands/router.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from "./types.js";
+export declare class CommandRouter {
+    private commands;
+    constructor();
+    register(cmd: Command): void;
+    handleMessage(bot: any, msg: any): Promise<void>;
+}

package/dist/commands/types.d.ts

@@ -0,0 +1,15 @@
+import type { ZaloPersonalBot } from "../personal/client.js";
+export interface CommandContext {
+    bot: ZaloPersonalBot;
+    msg: any;
+    args: string[];
+    isGroup: boolean;
+    threadId: string;
+}
+export interface Command {
+    name: string;
+    aliases?: string[];
+    description: string;
+    groupOnly?: boolean;
+    execute: (ctx: CommandContext) => Promise<void>;
+}

package/dist/config/env.d.ts

@@ -0,0 +1,13 @@
+export declare const CONFIG: {
+    PERSONAL: {
+        CRED_PATH: string;
+        DEFAULT_PREFIX: string;
+    };
+    OA: {
+        APP_ID: string;
+        APP_SECRET: string;
+        ACCESS_TOKEN: string;
+        REFRESH_TOKEN: string;
+        BASE_URL: string;
+    };
+};

package/dist/core/adapter.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "node:events";
+import type { ChannelType, IChannelAdapter, MediaPayload, SendOptions, SentMessageResult } from "./types";
+export declare abstract class BaseChannel extends EventEmitter implements IChannelAdapter {
+    abstract readonly name: ChannelType;
+    private _connected;
+    isConnected(): boolean;
+    protected setConnected(value: boolean): void;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract sendText(chatId: string, text: string, options?: SendOptions): Promise<SentMessageResult>;
+    abstract sendMedia(chatId: string, media: MediaPayload, options?: SendOptions): Promise<SentMessageResult>;
+}

package/dist/core/bus.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "node:events";
+import type { ChannelStatus, UnifiedMessage } from "./types";
+export interface ChannelEvents {
+    message: [msg: UnifiedMessage];
+    error: [err: Error];
+    status: [status: ChannelStatus];
+}
+export declare class ChannelEventBus extends EventEmitter {
+    emitMessage(msg: UnifiedMessage): boolean;
+    emitError(err: Error): boolean;
+    emitStatus(status: ChannelStatus): boolean;
+}

package/dist/core/context.d.ts

@@ -0,0 +1,9 @@
+import type { IChannelAdapter, MediaPayload, SendOptions, SentMessageResult, UnifiedMessage } from "./types";
+export interface MessageContext {
+    message: UnifiedMessage;
+    channel: IChannelAdapter;
+    reply: (text: string, options?: SendOptions) => Promise<SentMessageResult>;
+    replyMedia: (media: MediaPayload, options?: SendOptions) => Promise<SentMessageResult>;
+    react: (emoji: string) => Promise<void>;
+}
+export declare function createMessageContext(message: UnifiedMessage, channel: IChannelAdapter): MessageContext;

package/dist/core/hub.d.ts

@@ -0,0 +1,14 @@
+import { type MessageContext } from "./context";
+import type { IChannelAdapter } from "./types";
+export type MessageHandler = (ctx: MessageContext) => Promise<void> | void;
+export declare class ChannelHub {
+    private _channels;
+    private _bus;
+    private _messageHandlers;
+    register(channel: IChannelAdapter): this;
+    getChannel(name: string): IChannelAdapter | undefined;
+    listChannels(): string[];
+    onMessage(handler: MessageHandler): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./adapter";
+export * from "./bus";
+export * from "./context";
+export * from "./hub";

package/dist/core/index.js

@@ -0,0 +1,99 @@
+// 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/core/bus.ts
+import { EventEmitter as EventEmitter2 } from "node:events";
+
+class ChannelEventBus extends EventEmitter2 {
+  emitMessage(msg) {
+    return this.emit("message", msg);
+  }
+  emitError(err) {
+    return this.emit("error", err);
+  }
+  emitStatus(status) {
+    return this.emit("status", status);
+  }
+}
+// src/core/context.ts
+function createMessageContext(message, channel) {
+  return {
+    message,
+    channel,
+    reply: (text, options) => channel.sendText(message.chat.id, text, {
+      replyToId: message.id,
+      ...options
+    }),
+    replyMedia: (media, options) => channel.sendMedia(message.chat.id, media, {
+      replyToId: message.id,
+      ...options
+    }),
+    react: async (emoji) => {
+      if (channel.addReaction) {
+        await channel.addReaction(message.chat.id, message.id, emoji);
+      }
+    }
+  };
+}
+// src/core/hub.ts
+class ChannelHub {
+  _channels = new Map;
+  _bus = new ChannelEventBus;
+  _messageHandlers = [];
+  register(channel) {
+    if (this._channels.has(channel.name)) {
+      throw new Error(`Channel '${channel.name}' is already registered in ChannelHub.`);
+    }
+    this._channels.set(channel.name, channel);
+    channel.on("message", (msg) => {
+      this._bus.emitMessage(msg);
+      const ctx = createMessageContext(msg, channel);
+      for (const handler of this._messageHandlers) {
+        Promise.resolve(handler(ctx)).catch((err) => {
+          this._bus.emitError(err);
+        });
+      }
+    });
+    channel.on("error", (err) => {
+      this._bus.emitError(err);
+    });
+    return this;
+  }
+  getChannel(name) {
+    return this._channels.get(name);
+  }
+  listChannels() {
+    return Array.from(this._channels.keys());
+  }
+  onMessage(handler) {
+    this._messageHandlers.push(handler);
+    return this;
+  }
+  async start() {
+    const promises = Array.from(this._channels.values()).map((ch) => ch.connect());
+    await Promise.all(promises);
+  }
+  async stop() {
+    const promises = Array.from(this._channels.values()).map((ch) => ch.disconnect());
+    await Promise.all(promises);
+  }
+}
+export {
+  BaseChannel,
+  ChannelEventBus,
+  ChannelHub,
+  createMessageContext
+};

package/dist/core/types.d.ts

@@ -0,0 +1,63 @@
+export type ChannelType = "zalo" | "telegram" | "discord" | "slack" | string;
+export type ChatType = "dm" | "group" | "channel";
+export type MediaType = "image" | "video" | "audio" | "file";
+export interface MediaAttachment {
+    type: MediaType;
+    url: string;
+    filename?: string;
+    mimeType?: string;
+    size?: number;
+}
+export interface UnifiedMessage {
+    id: string;
+    channel: ChannelType;
+    sender: {
+        id: string;
+        name?: string;
+        username?: string;
+        avatarUrl?: string;
+        isBot?: boolean;
+    };
+    chat: {
+        id: string;
+        type: ChatType;
+        title?: string;
+    };
+    content: {
+        text: string;
+        attachments?: MediaAttachment[];
+        replyToId?: string;
+    };
+    raw: unknown;
+    timestamp: number;
+}
+export interface SendOptions {
+    replyToId?: string;
+    quote?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface MediaPayload {
+    type: MediaType;
+    source: string | Buffer | Uint8Array;
+    filename?: string;
+    caption?: string;
+    mimeType?: string;
+}
+export interface SentMessageResult {
+    messageId: string;
+    chatId: string;
+    timestamp: number;
+}
+export type ChannelStatus = "connected" | "disconnected" | "reconnecting";
+export interface IChannelAdapter {
+    readonly name: ChannelType;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    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>;
+    on(event: "message", handler: (msg: UnifiedMessage) => Promise<void> | void): this;
+    on(event: "error", handler: (err: Error) => void): this;
+    on(event: "status", handler: (status: ChannelStatus) => void): this;
+}