@shykaruu/jarvis-brain 0.4.0

package/src/comms/channels/discord.ts

@@ -0,0 +1,228 @@
+import { Client, GatewayIntentBits, Partials, type Message } from 'discord.js';
+import type { ChannelAdapter, ChannelHandler, ChannelMessage } from './telegram.ts';
+import type { STTProvider } from '../voice.ts';
+
+export class DiscordAdapter implements ChannelAdapter {
+  name = 'discord';
+  private token: string;
+  private handler: ChannelHandler | null = null;
+  private connected: boolean = false;
+  private client: Client | null = null;
+  private allowedUsers: string[];
+  private guildId: string | null;
+  private sttProvider: STTProvider | null;
+
+  constructor(token: string, opts?: {
+    allowedUsers?: string[];
+    guildId?: string;
+    sttProvider?: STTProvider;
+  }) {
+    this.token = token;
+    this.allowedUsers = opts?.allowedUsers ?? [];
+    this.guildId = opts?.guildId ?? null;
+    this.sttProvider = opts?.sttProvider ?? null;
+  }
+
+  setSTTProvider(provider: STTProvider): void {
+    this.sttProvider = provider;
+  }
+
+  async connect(): Promise<void> {
+    if (this.connected) {
+      console.warn('[DiscordAdapter] Already connected');
+      return;
+    }
+
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+      partials: [Partials.Channel],
+    });
+
+    // Wait for ready event
+    let loginTimeout: ReturnType<typeof setTimeout> | null = null;
+    const readyPromise = new Promise<void>((resolve, reject) => {
+      loginTimeout = setTimeout(() => reject(new Error('Discord login timed out')), 30000);
+
+      this.client!.once('ready', () => {
+        clearTimeout(loginTimeout!);
+        this.connected = true;
+        console.log(`[DiscordAdapter] Connected as: ${this.client!.user?.tag}`);
+        resolve();
+      });
+
+      this.client!.once('error', (err) => {
+        clearTimeout(loginTimeout!);
+        reject(err);
+      });
+    });
+
+    // Set up message handler
+    this.client.on('messageCreate', async (message: Message) => {
+      try {
+        await this.processMessage(message);
+      } catch (err) {
+        console.error('[DiscordAdapter] Unhandled error in processMessage:', err);
+      }
+    });
+
+    try {
+      await this.client.login(this.token);
+    } catch (err) {
+      // Clear the ready timeout to prevent unhandled rejection
+      if (loginTimeout) clearTimeout(loginTimeout);
+      this.client.destroy();
+      this.client = null;
+      throw err;
+    }
+    await readyPromise;
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.client) {
+      this.client.destroy();
+      this.client = null;
+    }
+    this.connected = false;
+    console.log('[DiscordAdapter] Disconnected');
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    if (!this.client) throw new Error('Discord not connected');
+
+    const channel = await this.client.channels.fetch(channelId);
+    if (!channel || !channel.isTextBased()) {
+      throw new Error(`Invalid or non-text channel: ${channelId}`);
+    }
+
+    const chunks = splitMessage(text, 2000);
+    for (const chunk of chunks) {
+      await (channel as any).send(chunk);
+    }
+  }
+
+  onMessage(handler: ChannelHandler): void {
+    this.handler = handler;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  private async processMessage(message: Message): Promise<void> {
+    // Ignore bot messages (including our own)
+    if (message.author.bot) return;
+    if (!this.handler) return;
+
+    // Security: check allowed users (empty = allow all)
+    if (this.allowedUsers.length > 0 && !this.allowedUsers.includes(message.author.id)) {
+      return;
+    }
+
+    // Security: check guild restriction
+    if (this.guildId && message.guildId && message.guildId !== this.guildId) {
+      return;
+    }
+
+    let text = message.content;
+
+    // Handle audio attachments via STT
+    const audioAttachment = message.attachments.find(a =>
+      a.contentType?.startsWith('audio/') ||
+      a.name?.endsWith('.ogg') ||
+      a.name?.endsWith('.mp3') ||
+      a.name?.endsWith('.wav') ||
+      a.name?.endsWith('.m4a')
+    );
+
+    if (audioAttachment && !text && this.sttProvider) {
+      try {
+        const resp = await fetch(audioAttachment.url);
+        if (!resp.ok) throw new Error(`Failed to download: ${resp.status}`);
+        const buffer = Buffer.from(await resp.arrayBuffer());
+        text = await this.sttProvider.transcribe(buffer);
+        console.log('[DiscordAdapter] Transcribed audio:', text.slice(0, 80));
+      } catch (err) {
+        console.error('[DiscordAdapter] STT error:', err);
+        await message.reply('Failed to transcribe audio. Please send text.');
+        return;
+      }
+    }
+
+    if (!text) return;
+
+    const channelMessage: ChannelMessage = {
+      id: message.id,
+      channel: 'discord',
+      from: message.author.username,
+      text,
+      timestamp: message.createdTimestamp,
+      metadata: {
+        userId: message.author.id,
+        channelId: message.channelId,
+        guildId: message.guildId,
+        isDM: !message.guildId,
+        isVoice: !!audioAttachment,
+      },
+    };
+
+    console.log('[DiscordAdapter] Message from', channelMessage.from, ':', text.slice(0, 80));
+
+    try {
+      // Show typing indicator
+      if (message.channel.isSendable()) {
+        await message.channel.sendTyping();
+      }
+
+      const response = await this.handler(channelMessage);
+
+      if (response) {
+        const chunks = splitMessage(response, 2000);
+        for (const chunk of chunks) {
+          await message.reply(chunk);
+        }
+      }
+    } catch (err) {
+      console.error('[DiscordAdapter] Error handling message:', err);
+      try {
+        await message.reply('Sorry, I encountered an error processing your message.');
+      } catch {
+        // Ignore send failure
+      }
+    }
+  }
+}
+
+export function splitMessage(text: string, maxLength: number): string[] {
+  if (text.length <= maxLength) return [text];
+
+  const chunks: string[] = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+
+    // Try to split at newline
+    let splitIdx = remaining.lastIndexOf('\n', maxLength);
+    if (splitIdx < maxLength / 2) {
+      // Try space
+      splitIdx = remaining.lastIndexOf(' ', maxLength);
+    }
+    if (splitIdx < maxLength / 2) {
+      // Hard split
+      splitIdx = maxLength;
+    }
+
+    chunks.push(remaining.slice(0, splitIdx));
+    remaining = remaining.slice(splitIdx).trimStart();
+  }
+
+  return chunks;
+}

package/src/comms/channels/signal.ts

@@ -0,0 +1,56 @@
+import type { ChannelAdapter, ChannelHandler, ChannelMessage } from './telegram.ts';
+
+export class SignalAdapter implements ChannelAdapter {
+  name = 'signal';
+  private phone: string;
+  private handler: ChannelHandler | null = null;
+  private connected: boolean = false;
+
+  constructor(config: { phone: string }) {
+    this.phone = config.phone;
+  }
+
+  async connect(): Promise<void> {
+    throw new Error(
+      'Signal adapter not yet implemented. Requires signal-cli setup. ' +
+      'Install signal-cli: https://github.com/AsamK/signal-cli'
+    );
+
+    // Future implementation would use signal-cli in daemon mode:
+    // 1. Ensure signal-cli is installed and registered with phone number
+    // 2. Start signal-cli in daemon mode with D-Bus interface
+    // 3. Subscribe to message events via D-Bus
+    // 4. Set this.connected = true
+    //
+    // Example using signal-cli REST API mode:
+    // Start signal-cli with: signal-cli -a <PHONE> daemon --http localhost:8080
+    // Then connect via HTTP API
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  async sendMessage(recipient: string, text: string): Promise<void> {
+    throw new Error('Signal adapter not yet implemented.');
+
+    // Future implementation using signal-cli REST API:
+    // await fetch('http://localhost:8080/v2/send', {
+    //   method: 'POST',
+    //   headers: { 'Content-Type': 'application/json' },
+    //   body: JSON.stringify({
+    //     number: this.phone,
+    //     recipients: [recipient],
+    //     message: text,
+    //   }),
+    // });
+  }
+
+  onMessage(handler: ChannelHandler): void {
+    this.handler = handler;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+}

package/src/comms/channels/telegram.ts

@@ -0,0 +1,316 @@
+import type { STTProvider } from '../voice.ts';
+
+export type ChannelMessage = {
+  id: string;
+  channel: string;
+  from: string;
+  text: string;
+  timestamp: number;
+  metadata: Record<string, unknown>;
+};
+
+export type ChannelHandler = (message: ChannelMessage) => Promise<string>;
+
+export interface ChannelAdapter {
+  name: string;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  sendMessage(to: string, text: string): Promise<void>;
+  onMessage(handler: ChannelHandler): void;
+  isConnected(): boolean;
+}
+
+type TelegramUpdate = {
+  update_id: number;
+  message?: {
+    message_id: number;
+    from: {
+      id: number;
+      first_name: string;
+      last_name?: string;
+      username?: string;
+    };
+    chat: {
+      id: number;
+      type: string;
+    };
+    date: number;
+    text?: string;
+    voice?: {
+      duration: number;
+      mime_type: string;
+      file_id: string;
+      file_unique_id: string;
+      file_size?: number;
+    };
+    audio?: {
+      duration: number;
+      mime_type: string;
+      file_id: string;
+      file_unique_id: string;
+      file_size?: number;
+    };
+  };
+};
+
+type TelegramGetUpdatesResponse = {
+  ok: boolean;
+  result: TelegramUpdate[];
+};
+
+export class TelegramAdapter implements ChannelAdapter {
+  name = 'telegram';
+  private token: string;
+  private handler: ChannelHandler | null = null;
+  private polling: boolean = false;
+  private offset: number = 0;
+  private baseUrl: string;
+  private pollingInterval: number = 1000;
+  private sttProvider: STTProvider | null = null;
+  private allowedUsers: number[];
+
+  constructor(token: string, opts?: { sttProvider?: STTProvider; allowedUsers?: number[] }) {
+    this.token = token;
+    this.baseUrl = `https://api.telegram.org/bot${token}`;
+    this.sttProvider = opts?.sttProvider ?? null;
+    this.allowedUsers = opts?.allowedUsers ?? [];
+  }
+
+  setSTTProvider(provider: STTProvider): void {
+    this.sttProvider = provider;
+  }
+
+  async connect(): Promise<void> {
+    if (this.polling) {
+      console.warn('[TelegramAdapter] Already connected');
+      return;
+    }
+
+    // Verify bot token by calling getMe
+    try {
+      const response = await fetch(`${this.baseUrl}/getMe`);
+      const data = await response.json() as any;
+
+      if (!data.ok) {
+        throw new Error(`Invalid bot token: ${data.description}`);
+      }
+
+      console.log('[TelegramAdapter] Connected as:', data.result.username);
+    } catch (error) {
+      throw new Error(
+        `Failed to connect to Telegram: ${error instanceof Error ? error.message : 'Unknown error'}`
+      );
+    }
+
+    this.polling = true;
+    this.startPolling();
+  }
+
+  async disconnect(): Promise<void> {
+    this.polling = false;
+    console.log('[TelegramAdapter] Disconnected');
+  }
+
+  async sendMessage(chatId: string, text: string): Promise<void> {
+    // Telegram has a 4096 char limit per message
+    const chunks = splitText(text, 4096);
+    for (const chunk of chunks) {
+      try {
+        const response = await fetch(`${this.baseUrl}/sendMessage`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            chat_id: chatId,
+            text: chunk,
+            parse_mode: 'Markdown',
+          }),
+        });
+
+        const data = await response.json() as any;
+
+        if (!data.ok) {
+          // Retry without Markdown if parsing failed
+          if (data.description?.includes('parse')) {
+            await fetch(`${this.baseUrl}/sendMessage`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ chat_id: chatId, text: chunk }),
+            });
+          } else {
+            throw new Error(`Telegram API error: ${data.description}`);
+          }
+        }
+      } catch (error) {
+        console.error('[TelegramAdapter] Error sending message:', error);
+        throw error;
+      }
+    }
+  }
+
+  onMessage(handler: ChannelHandler): void {
+    this.handler = handler;
+  }
+
+  isConnected(): boolean {
+    return this.polling;
+  }
+
+  private async startPolling(): Promise<void> {
+    console.log('[TelegramAdapter] Starting polling...');
+
+    while (this.polling) {
+      try {
+        const updates = await this.getUpdates();
+
+        for (const update of updates) {
+          await this.processUpdate(update);
+        }
+      } catch (error) {
+        console.error('[TelegramAdapter] Polling error:', error);
+      }
+
+      await new Promise(resolve => setTimeout(resolve, this.pollingInterval));
+    }
+
+    console.log('[TelegramAdapter] Polling stopped');
+  }
+
+  private async getUpdates(): Promise<TelegramUpdate[]> {
+    const response = await fetch(`${this.baseUrl}/getUpdates`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        offset: this.offset,
+        timeout: 30,
+        allowed_updates: ['message'],
+      }),
+    });
+
+    const data: TelegramGetUpdatesResponse = await response.json() as TelegramGetUpdatesResponse;
+
+    if (!data.ok) {
+      throw new Error('Failed to get updates');
+    }
+
+    if (data.result.length > 0) {
+      this.offset = data.result[data.result.length - 1]!.update_id + 1;
+    }
+
+    return data.result;
+  }
+
+  private async processUpdate(update: TelegramUpdate): Promise<void> {
+    if (!update.message || !this.handler) return;
+
+    const { message } = update;
+
+    // Security: check allowed users
+    if (this.allowedUsers.length > 0 && !this.allowedUsers.includes(message.from.id)) {
+      console.log(`[TelegramAdapter] Ignoring message from unauthorized user: ${message.from.id} (${message.from.username ?? message.from.first_name})`);
+      return;
+    }
+
+    let text = message.text ?? '';
+
+    // Handle voice/audio messages via STT
+    const voiceFile = message.voice ?? message.audio;
+    if (voiceFile && !text) {
+      if (!this.sttProvider) {
+        await this.sendMessage(
+          message.chat.id.toString(),
+          'Voice messages require STT configuration. Set up an STT provider in the Dashboard Settings.'
+        );
+        return;
+      }
+      try {
+        const audioBuffer = await this.downloadFile(voiceFile.file_id);
+        text = await this.sttProvider.transcribe(audioBuffer);
+        console.log('[TelegramAdapter] Transcribed voice:', text.slice(0, 80));
+      } catch (err) {
+        console.error('[TelegramAdapter] STT error:', err);
+        await this.sendMessage(
+          message.chat.id.toString(),
+          'Failed to transcribe voice message. Please try sending text.'
+        );
+        return;
+      }
+    }
+
+    if (!text) return;
+
+    const channelMessage: ChannelMessage = {
+      id: message.message_id.toString(),
+      channel: 'telegram',
+      from: message.from.username || message.from.first_name,
+      text,
+      timestamp: message.date * 1000,
+      metadata: {
+        chatId: message.chat.id,
+        userId: message.from.id,
+        chatType: message.chat.type,
+        firstName: message.from.first_name,
+        lastName: message.from.last_name,
+        isVoice: !!voiceFile,
+      },
+    };
+
+    console.log('[TelegramAdapter] Message from', channelMessage.from, ':', channelMessage.text.slice(0, 80));
+
+    try {
+      const response = await this.handler(channelMessage);
+
+      if (response) {
+        await this.sendMessage(message.chat.id.toString(), response);
+      }
+    } catch (error) {
+      console.error('[TelegramAdapter] Error handling message:', error);
+
+      await this.sendMessage(
+        message.chat.id.toString(),
+        'Sorry, I encountered an error processing your message.'
+      );
+    }
+  }
+
+  private async downloadFile(fileId: string): Promise<Buffer> {
+    // Step 1: Get file path from Telegram
+    const fileResp = await fetch(`${this.baseUrl}/getFile`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ file_id: fileId }),
+    });
+    const fileData = await fileResp.json() as any;
+
+    if (!fileData.ok) {
+      throw new Error(`Failed to get file info: ${fileData.description}`);
+    }
+
+    // Step 2: Download the actual file
+    const filePath = fileData.result.file_path;
+    const downloadUrl = `https://api.telegram.org/file/bot${this.token}/${filePath}`;
+    const downloadResp = await fetch(downloadUrl);
+
+    if (!downloadResp.ok) {
+      throw new Error(`Failed to download file: ${downloadResp.status}`);
+    }
+
+    return Buffer.from(await downloadResp.arrayBuffer());
+  }
+}
+
+function splitText(text: string, maxLength: number): string[] {
+  if (text.length <= maxLength) return [text];
+  const chunks: string[] = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitIdx = remaining.lastIndexOf('\n', maxLength);
+    if (splitIdx < maxLength / 2) splitIdx = maxLength;
+    chunks.push(remaining.slice(0, splitIdx));
+    remaining = remaining.slice(splitIdx);
+  }
+  return chunks;
+}

package/src/comms/channels/whatsapp.ts

@@ -0,0 +1,60 @@
+import type { ChannelAdapter, ChannelHandler, ChannelMessage } from './telegram.ts';
+
+export class WhatsAppAdapter implements ChannelAdapter {
+  name = 'whatsapp';
+  private phoneNumberId: string;
+  private accessToken: string;
+  private handler: ChannelHandler | null = null;
+  private connected: boolean = false;
+
+  constructor(config: { phoneNumberId: string; accessToken: string }) {
+    this.phoneNumberId = config.phoneNumberId;
+    this.accessToken = config.accessToken;
+  }
+
+  async connect(): Promise<void> {
+    throw new Error(
+      'WhatsApp adapter not yet implemented. Requires WhatsApp Business API setup. ' +
+      'Visit https://developers.facebook.com/docs/whatsapp/cloud-api/get-started'
+    );
+
+    // Future implementation would:
+    // 1. Set up webhook endpoint for incoming messages
+    // 2. Verify webhook with Facebook/Meta
+    // 3. Start listening for webhook events
+    // 4. Set this.connected = true
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  async sendMessage(to: string, text: string): Promise<void> {
+    throw new Error('WhatsApp adapter not yet implemented.');
+
+    // Future implementation:
+    // const response = await fetch(
+    //   `https://graph.facebook.com/v18.0/${this.phoneNumberId}/messages`,
+    //   {
+    //     method: 'POST',
+    //     headers: {
+    //       'Authorization': `Bearer ${this.accessToken}`,
+    //       'Content-Type': 'application/json',
+    //     },
+    //     body: JSON.stringify({
+    //       messaging_product: 'whatsapp',
+    //       to,
+    //       text: { body: text },
+    //     }),
+    //   }
+    // );
+  }
+
+  onMessage(handler: ChannelHandler): void {
+    this.handler = handler;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+}