@johpaz/hive-core 0.1.1

package/src/channels/base.ts

@@ -0,0 +1,91 @@
+export interface OutboundMessage {
+  type: "message" | "stream" | "status" | "error" | "pong" | "command_result";
+  sessionId: string;
+  content?: string;
+  chunk?: string;
+  isLast?: boolean;
+  status?: {
+    state: string;
+    model?: string;
+    tokens?: number;
+  };
+  error?: string;
+  result?: unknown;
+}
+
+export interface IncomingMessage {
+  sessionId: string;
+  channel: string;
+  accountId: string;
+  peerId: string;
+  peerKind: "direct" | "group";
+  content: string;
+  metadata?: Record<string, unknown>;
+  replyToId?: string;
+}
+
+export interface ChannelConfig {
+  enabled: boolean;
+  dmPolicy: "open" | "pairing" | "allowlist";
+  allowFrom: string[];
+}
+
+export interface IChannel {
+  name: string;
+  accountId: string;
+  config: ChannelConfig;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  send(sessionId: string, message: OutboundMessage): Promise<void>;
+  onMessage(handler: MessageHandler): void;
+  isRunning(): boolean;
+}
+
+export type MessageHandler = (message: IncomingMessage) => Promise<void>;
+
+export abstract class BaseChannel implements IChannel {
+  abstract name: string;
+  abstract accountId: string;
+  abstract config: ChannelConfig;
+  
+  protected messageHandler?: MessageHandler;
+  protected running = false;
+
+  abstract start(): Promise<void>;
+  abstract stop(): Promise<void>;
+  abstract send(sessionId: string, message: OutboundMessage): Promise<void>;
+
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  protected async handleMessage(message: IncomingMessage): Promise<void> {
+    if (this.messageHandler) {
+      await this.messageHandler(message);
+    }
+  }
+
+  protected isUserAllowed(peerId: string): boolean {
+    if (this.config.dmPolicy === "open") {
+      return true;
+    }
+
+    if (this.config.dmPolicy === "allowlist") {
+      return this.config.allowFrom.includes(peerId);
+    }
+
+    if (this.config.dmPolicy === "pairing") {
+      return this.config.allowFrom.includes(peerId);
+    }
+
+    return false;
+  }
+
+  protected formatSessionId(peerId: string, kind: "direct" | "group"): string {
+    return `agent:main:${this.name}:${kind}:${peerId}`;
+  }
+}

package/src/channels/discord.ts

@@ -0,0 +1,185 @@
+import {
+  Client,
+  GatewayIntentBits,
+  Events,
+  type Message,
+  type TextChannel,
+  type DMChannel,
+  type NewsChannel,
+} from "discord.js";
+import { BaseChannel, type ChannelConfig, type IncomingMessage, type OutboundMessage } from "./base.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface DiscordConfig extends ChannelConfig {
+  botToken: string;
+  applicationId?: string;
+  guilds?: Record<string, unknown>;
+}
+
+type DiscordTextChannel = TextChannel | DMChannel | NewsChannel;
+
+export class DiscordChannel extends BaseChannel {
+  name = "discord";
+  accountId: string;
+  config: DiscordConfig;
+  
+  private client?: Client;
+  private log = logger.child("discord");
+
+  constructor(accountId: string, config: DiscordConfig) {
+    super();
+    this.accountId = accountId;
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.botToken) {
+      throw new Error("Discord bot token not configured");
+    }
+
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+    });
+
+    this.client.on(Events.MessageCreate, async (message) => {
+      await this.handleDiscordMessage(message);
+    });
+
+    this.client.on(Events.Error, (error) => {
+      this.log.error(`Discord client error: ${error.message}`);
+    });
+
+    this.client.once(Events.ClientReady, () => {
+      this.log.info(`Discord bot started: ${this.client?.user?.tag ?? "unknown"}`);
+      this.running = true;
+    });
+
+    try {
+      await this.client.login(this.config.botToken);
+    } catch (error) {
+      this.log.error(`Failed to login to Discord: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  private async handleDiscordMessage(message: Message): Promise<void> {
+    if (message.author.bot) return;
+
+    const isGuild = message.guild !== null;
+    const kind = isGuild ? "group" : "direct";
+    const peerId = isGuild 
+      ? `${message.guildId}:${message.channelId}:${message.author.id}`
+      : message.author.id;
+
+    if (!isGuild && !this.isUserAllowed(message.author.id)) {
+      this.log.debug(`Message from unauthorized user: ${message.author.id}`);
+      return;
+    }
+
+    const incomingMessage: IncomingMessage = {
+      sessionId: this.formatSessionId(peerId, kind),
+      channel: "discord",
+      accountId: this.accountId,
+      peerId,
+      peerKind: kind,
+      content: message.content,
+      metadata: {
+        discord: {
+          guildId: message.guildId,
+          channelId: message.channelId,
+          userId: message.author.id,
+          username: message.author.username,
+          messageId: message.id,
+          roles: message.member?.roles.cache.map(r => r.id),
+        },
+      },
+      replyToId: message.reference?.messageId 
+        ? `discord:${message.reference.messageId}` 
+        : undefined,
+    };
+
+    await this.handleMessage(incomingMessage);
+  }
+
+  async stop(): Promise<void> {
+    if (this.client) {
+      this.client.destroy();
+      this.running = false;
+      this.log.info("Discord bot stopped");
+    }
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    if (!this.client) {
+      throw new Error("Discord client not started");
+    }
+
+    const parts = sessionId.split(":");
+    const peerPart = parts.slice(3).join(":");
+    
+    let channelId: string;
+    if (peerPart.includes(":")) {
+      const channelPart = peerPart.split(":");
+      channelId = channelPart[1] ?? peerPart;
+    } else {
+      channelId = peerPart;
+    }
+
+    const channel = await this.client.channels.fetch(channelId);
+    
+    if (!channel || !channel.isTextBased()) {
+      throw new Error(`Channel not found or not text-based: ${channelId}`);
+    }
+
+    const content = message.content ?? "";
+    const maxLength = 2000;
+
+    try {
+      if (content.length <= maxLength) {
+        await (channel as DiscordTextChannel).send(content);
+      } else {
+        const chunks = this.chunkMessage(content, maxLength);
+        for (const chunk of chunks) {
+          await (channel as DiscordTextChannel).send(chunk);
+        }
+      }
+    } catch (error) {
+      this.log.error(`Failed to send Discord message: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  private chunkMessage(content: string, maxLength: number): string[] {
+    const chunks: string[] = [];
+    let remaining = content;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= maxLength) {
+        chunks.push(remaining);
+        break;
+      }
+
+      let splitPoint = remaining.lastIndexOf("\n", maxLength);
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = remaining.lastIndexOf(" ", maxLength);
+      }
+      if (splitPoint === -1 || splitPoint < maxLength * 0.5) {
+        splitPoint = maxLength;
+      }
+
+      chunks.push(remaining.slice(0, splitPoint));
+      remaining = remaining.slice(splitPoint).trim();
+    }
+
+    return chunks;
+  }
+}
+
+export function createDiscordChannel(accountId: string, config: DiscordConfig): DiscordChannel {
+  return new DiscordChannel(accountId, config);
+}

package/src/channels/index.ts

@@ -0,0 +1,7 @@
+export * from "./base.ts";
+export * from "./telegram.ts";
+export * from "./discord.ts";
+export * from "./webchat.ts";
+export * from "./whatsapp.ts";
+export * from "./slack.ts";
+export * from "./manager.ts";

package/src/channels/manager.ts

@@ -0,0 +1,204 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import type { IChannel, IncomingMessage, MessageHandler } from "./base.ts";
+import { createTelegramChannel, type TelegramConfig } from "./telegram.ts";
+import { createDiscordChannel, type DiscordConfig } from "./discord.ts";
+import { createWebChatChannel, type WebChatConfig } from "./webchat.ts";
+import { createWhatsAppChannel, type WhatsAppConfig } from "./whatsapp.ts";
+import { createSlackChannel, type SlackConfig } from "./slack.ts";
+
+export class ChannelManager {
+  private config: Config;
+  private channels: Map<string, IChannel> = new Map();
+  private messageHandler?: MessageHandler;
+  private log = logger.child("channels");
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  async initialize(): Promise<void> {
+    const channelConfigs = this.config.channels ?? {};
+
+    for (const [channelName, channelConfig] of Object.entries(channelConfigs)) {
+      if (!channelConfig.enabled) {
+        this.log.debug(`Channel ${channelName} is disabled`);
+        continue;
+      }
+
+      if ((channelConfig as any)._experimental) {
+        this.log.warn(`Channel ${channelName} is EXPERIMENTAL - may be unstable`);
+        if ((channelConfig as any)._warning) {
+          this.log.warn((channelConfig as any)._warning);
+        }
+      }
+
+      const accounts = channelConfig.accounts ?? { default: channelConfig };
+
+      for (const [accountId, accountConfig] of Object.entries(accounts)) {
+        const fullConfig = { ...channelConfig, ...accountConfig };
+        await this.createChannel(channelName, accountId, fullConfig);
+      }
+    }
+
+    this.log.info(`Initialized ${this.channels.size} channel(s)`);
+  }
+
+  private async createChannel(
+    channelName: string,
+    accountId: string,
+    config: Record<string, unknown>
+  ): Promise<void> {
+    let channel: IChannel;
+
+    try {
+      switch (channelName) {
+        case "telegram":
+          channel = createTelegramChannel(accountId, {
+            enabled: true,
+            botToken: config.botToken as string,
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "pairing",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+            groups: (config.groups as boolean) ?? false,
+          } as TelegramConfig);
+          break;
+
+        case "discord":
+          channel = createDiscordChannel(accountId, {
+            enabled: true,
+            botToken: config.botToken as string,
+            applicationId: config.applicationId as string,
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "allowlist",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+          } as DiscordConfig);
+          break;
+
+        case "webchat":
+          channel = createWebChatChannel({
+            enabled: true,
+            dmPolicy: "open",
+            allowFrom: [],
+          } as WebChatConfig);
+          break;
+
+        case "whatsapp":
+          channel = createWhatsAppChannel({
+            enabled: true,
+            accountId,
+            agentId: (config.agentId as string) ?? "main",
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "allowlist",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+            reconnectMaxAttempts: (config.reconnectMaxAttempts as number) ?? 10,
+            reconnectBaseDelayMs: (config.reconnectBaseDelayMs as number) ?? 5000,
+          } as WhatsAppConfig);
+          break;
+
+        case "slack":
+          channel = createSlackChannel({
+            enabled: true,
+            botToken: config.botToken as string,
+            appToken: config.appToken as string,
+            signingSecret: config.signingSecret as string,
+            port: (config.port as number) ?? 3000,
+            dmPolicy: (config.dmPolicy as "open" | "pairing" | "allowlist") ?? "allowlist",
+            allowFrom: (config.allowFrom as string[]) ?? [],
+          } as SlackConfig);
+          break;
+
+        default:
+          this.log.warn(`Unknown channel type: ${channelName}`);
+          return;
+      }
+
+      channel.onMessage(async (message: IncomingMessage) => {
+        if (this.messageHandler) {
+          await this.messageHandler(message);
+        }
+      });
+
+      const key = `${channelName}:${accountId}`;
+      this.channels.set(key, channel);
+
+      this.log.info(`Created channel: ${key}`);
+    } catch (error) {
+      this.log.error(`Failed to create channel ${channelName}:${accountId}: ${(error as Error).message}`);
+    }
+  }
+
+  async startAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
+
+    for (const [key, channel] of this.channels) {
+      promises.push(
+        channel.start().catch((error) => {
+          this.log.error(`Failed to start channel ${key}: ${error.message}`);
+        })
+      );
+    }
+
+    await Promise.allSettled(promises);
+    this.log.info("All channels started");
+  }
+
+  async stopAll(): Promise<void> {
+    const promises: Promise<void>[] = [];
+
+    for (const [key, channel] of this.channels) {
+      promises.push(
+        channel.stop().catch((error) => {
+          this.log.error(`Failed to stop channel ${key}: ${error.message}`);
+        })
+      );
+    }
+
+    await Promise.allSettled(promises);
+    this.log.info("All channels stopped");
+  }
+
+  getChannel(channelName: string, accountId?: string): IChannel | undefined {
+    if (accountId) {
+      return this.channels.get(`${channelName}:${accountId}`);
+    }
+
+    for (const [key, channel] of this.channels) {
+      if (key.startsWith(channelName)) {
+        return channel;
+      }
+    }
+
+    return undefined;
+  }
+
+  listChannels(): Array<{ name: string; accountId: string; running: boolean }> {
+    return Array.from(this.channels.entries()).map(([key, channel]) => {
+      const [name, accountId] = key.split(":");
+      return {
+        name: name ?? "unknown",
+        accountId: accountId ?? "default",
+        running: channel.isRunning(),
+      };
+    });
+  }
+
+  async send(
+    channelName: string,
+    sessionId: string,
+    message: unknown
+  ): Promise<void> {
+    const channel = this.getChannel(channelName);
+    
+    if (!channel) {
+      throw new Error(`Channel not found: ${channelName}`);
+    }
+
+    await channel.send(sessionId, message as any);
+  }
+}
+
+export function createChannelManager(config: Config): ChannelManager {
+  return new ChannelManager(config);
+}

package/src/channels/slack.ts

@@ -0,0 +1,209 @@
+import { App, ExpressReceiver, type SlashCommand } from "@slack/bolt";
+import type { ChannelConfig, IncomingMessage, OutboundMessage } from "./base.ts";
+import { BaseChannel } from "./base.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface SlackConfig extends ChannelConfig {
+  botToken: string;
+  appToken: string;
+  signingSecret: string;
+  port?: number;
+}
+
+export interface SlackConnectionState {
+  status: "connecting" | "connected" | "disconnected" | "error";
+  error?: string;
+}
+
+export class SlackChannel extends BaseChannel {
+  name = "slack";
+  accountId: string;
+  config: SlackConfig;
+  
+  private app: App | null = null;
+  private connectionState: SlackConnectionState = {
+    status: "disconnected",
+  };
+  private log = logger.child("slack");
+
+  constructor(config: SlackConfig) {
+    super();
+    this.config = config;
+    this.accountId = config.botToken.split(":")[0]?.replace("xoxb-", "") ?? "default";
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+    this.connectionState.status = "connecting";
+
+    this.log.warn(`
+╔══════════════════════════════════════════════════════════════════╗
+║  SLACK CHANNEL SETUP REQUIREMENT                                  ║
+║                                                                  ║
+║  Slack requires a PUBLIC URL for webhooks.                       ║
+║  For local development, use one of:                              ║
+║                                                                  ║
+║  1. ngrok:     ngrok http 3000                                   ║
+║  2. Tailscale: tailscale fun                                     ║
+║  3. cloudflared tunnel --url http://localhost:3000               ║
+║                                                                  ║
+║  Then configure in Slack App settings:                           ║
+║  - Request URL: https://your-tunnel-url/slack/events            ║
+╚══════════════════════════════════════════════════════════════════╝
+`);
+
+    try {
+      const receiver = new ExpressReceiver({
+        signingSecret: this.config.signingSecret,
+        endpoints: "/slack/events",
+        processBeforeResponse: true,
+      });
+
+      this.app = new App({
+        token: this.config.botToken,
+        appToken: this.config.appToken,
+        receiver,
+      });
+
+      this.app.event("app_mention", async ({ event }) => {
+        await this.handleMention(event);
+      });
+
+      this.app.event("message", async ({ event }) => {
+        if ((event as any).channel_type === "im") {
+          await this.handleDirectMessage(event as any);
+        }
+      });
+
+      this.app.command("/ai", async ({ command, ack }) => {
+        await ack();
+        await this.handleSlashCommand(command);
+      });
+
+      const port = this.config.port ?? 3000;
+      
+      await this.app.start(port);
+      
+      this.connectionState.status = "connected";
+      this.log.info(`Slack channel started on port ${port}`);
+
+    } catch (error) {
+      this.connectionState.status = "error";
+      this.connectionState.error = (error as Error).message;
+      this.log.error(`Slack connection error: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+
+    if (this.app) {
+      try {
+        await this.app.stop();
+      } catch {
+        // Ignore close errors
+      }
+      this.app = null;
+    }
+
+    this.connectionState.status = "disconnected";
+    this.log.info("Slack channel stopped");
+  }
+
+  private async handleMention(event: { user?: string; text?: string; channel?: string; ts?: string }): Promise<void> {
+    if (!event.user || !event.text || !event.channel) return;
+
+    const content = event.text.replace(/<@[A-Z0-9]+>/g, "").trim();
+    if (!content) return;
+
+    const incoming: IncomingMessage = {
+      sessionId: this.formatSessionId(event.channel, "group"),
+      channel: "slack",
+      accountId: this.accountId,
+      peerId: event.channel,
+      peerKind: "group",
+      content,
+      metadata: {
+        userId: event.user,
+        timestamp: event.ts,
+      },
+    };
+
+    await this.handleMessage(incoming);
+  }
+
+  private async handleDirectMessage(event: { user?: string; text?: string; channel?: string; ts?: string }): Promise<void> {
+    if (!event.user || !event.text || !event.channel) return;
+    if (event.text.startsWith("/")) return;
+
+    const incoming: IncomingMessage = {
+      sessionId: this.formatSessionId(event.user, "direct"),
+      channel: "slack",
+      accountId: this.accountId,
+      peerId: event.user,
+      peerKind: "direct",
+      content: event.text,
+      metadata: {
+        channel: event.channel,
+        timestamp: event.ts,
+      },
+    };
+
+    await this.handleMessage(incoming);
+  }
+
+  private async handleSlashCommand(command: SlashCommand): Promise<void> {
+    const incoming: IncomingMessage = {
+      sessionId: this.formatSessionId(command.user_id, "direct"),
+      channel: "slack",
+      accountId: this.accountId,
+      peerId: command.user_id,
+      peerKind: "direct",
+      content: command.text,
+      metadata: {
+        channelId: command.channel_id,
+        command: command.command,
+        triggerId: command.trigger_id,
+      },
+    };
+
+    await this.handleMessage(incoming);
+  }
+
+  async send(sessionId: string, message: OutboundMessage): Promise<void> {
+    if (!this.app) {
+      throw new Error("Slack not connected");
+    }
+
+    const text = message.content ?? message.chunk ?? "";
+    if (!text) return;
+
+    const peerId = this.extractPeerId(sessionId);
+
+    try {
+      await this.app.client.chat.postMessage({
+        channel: peerId,
+        text,
+      });
+
+      this.log.debug(`Sent message to ${peerId}`);
+    } catch (error) {
+      this.log.error(`Failed to send Slack message: ${(error as Error).message}`);
+      throw error;
+    }
+  }
+
+  private extractPeerId(sessionId: string): string {
+    const parts = sessionId.split(":");
+    return parts[parts.length - 1] ?? "";
+  }
+
+  getState(): SlackConnectionState {
+    return { ...this.connectionState };
+  }
+}
+
+export function createSlackChannel(config: SlackConfig): SlackChannel {
+  return new SlackChannel(config);
+}