@usejarvis/brain 0.1.0

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;
+  }
+}

package/src/comms/channels.test.ts

@@ -0,0 +1,173 @@
+import { test, expect, describe } from 'bun:test';
+import { ChannelManager } from './index.ts';
+import type { ChannelAdapter, ChannelMessage } from './channels/telegram.ts';
+import { splitMessage } from './channels/discord.ts';
+
+// Mock channel adapter for testing
+class MockChannel implements ChannelAdapter {
+  name = 'mock';
+  private _connected = false;
+  private _handler: ((msg: ChannelMessage) => Promise<string>) | null = null;
+
+  async connect(): Promise<void> {
+    this._connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this._connected = false;
+  }
+
+  async sendMessage(to: string, text: string): Promise<void> {
+    // Mock implementation
+  }
+
+  onMessage(handler: (msg: ChannelMessage) => Promise<string>): void {
+    this._handler = handler;
+  }
+
+  isConnected(): boolean {
+    return this._connected;
+  }
+
+  // Test helper to simulate receiving a message
+  async simulateMessage(text: string): Promise<string | null> {
+    if (!this._handler) return null;
+
+    const msg: ChannelMessage = {
+      id: '1',
+      channel: 'mock',
+      from: 'testuser',
+      text,
+      timestamp: Date.now(),
+      metadata: {},
+    };
+
+    return this._handler(msg);
+  }
+}
+
+test('ChannelManager - register channel', () => {
+  const manager = new ChannelManager();
+  const channel = new MockChannel();
+
+  manager.register(channel);
+  expect(manager.listChannels()).toEqual(['mock']);
+  expect(manager.getChannel('mock')).toBe(channel);
+});
+
+test('ChannelManager - set handler', async () => {
+  const manager = new ChannelManager();
+  const channel = new MockChannel();
+
+  manager.register(channel);
+
+  let handlerCalled = false;
+  manager.setHandler(async (msg) => {
+    handlerCalled = true;
+    return `Echo: ${msg.text}`;
+  });
+
+  const response = await channel.simulateMessage('test');
+  expect(handlerCalled).toBe(true);
+  expect(response).toBe('Echo: test');
+});
+
+test('ChannelManager - connect all channels', async () => {
+  const manager = new ChannelManager();
+  const channel1 = new MockChannel();
+  const channel2 = new MockChannel();
+  channel2.name = 'mock2';
+
+  manager.register(channel1);
+  manager.register(channel2);
+
+  await manager.connectAll();
+
+  const status = manager.getStatus();
+  expect(status.mock).toBe(true);
+  expect(status.mock2).toBe(true);
+});
+
+test('ChannelManager - disconnect all channels', async () => {
+  const manager = new ChannelManager();
+  const channel = new MockChannel();
+
+  manager.register(channel);
+  await manager.connectAll();
+
+  expect(manager.getStatus().mock).toBe(true);
+
+  await manager.disconnectAll();
+  expect(manager.getStatus().mock).toBe(false);
+});
+
+test('ChannelManager - list channels', () => {
+  const manager = new ChannelManager();
+
+  expect(manager.listChannels()).toEqual([]);
+
+  manager.register(new MockChannel());
+  expect(manager.listChannels()).toEqual(['mock']);
+
+  const channel2 = new MockChannel();
+  channel2.name = 'mock2';
+  manager.register(channel2);
+
+  expect(manager.listChannels()).toContain('mock');
+  expect(manager.listChannels()).toContain('mock2');
+});
+
+// Discord splitMessage tests
+describe('Discord splitMessage', () => {
+  test('returns single chunk for short message', () => {
+    const result = splitMessage('Hello world', 2000);
+    expect(result).toEqual(['Hello world']);
+  });
+
+  test('returns single chunk for message exactly at limit', () => {
+    const text = 'a'.repeat(2000);
+    const result = splitMessage(text, 2000);
+    expect(result).toEqual([text]);
+  });
+
+  test('splits long message at newline boundary', () => {
+    const line = 'This is a line of text\n';
+    // Create text that exceeds 100 chars, with newlines
+    const text = line.repeat(10); // 220 chars
+    const result = splitMessage(text, 100);
+    expect(result.length).toBeGreaterThan(1);
+    // Each chunk should be <= 100 chars
+    for (const chunk of result) {
+      expect(chunk.length).toBeLessThanOrEqual(100);
+    }
+    // Recombined should equal original (modulo trimmed whitespace)
+    const recombined = result.join('');
+    // The original text is preserved (whitespace trimming might remove leading spaces between chunks)
+    expect(recombined.replace(/\s+/g, '')).toBe(text.replace(/\s+/g, ''));
+  });
+
+  test('hard splits when no good break point', () => {
+    // No spaces or newlines — must hard split
+    const text = 'a'.repeat(5000);
+    const result = splitMessage(text, 2000);
+    expect(result.length).toBe(3); // 2000 + 2000 + 1000
+    expect(result[0]!.length).toBe(2000);
+    expect(result[1]!.length).toBe(2000);
+    expect(result[2]!.length).toBe(1000);
+  });
+
+  test('handles empty string', () => {
+    const result = splitMessage('', 2000);
+    expect(result).toEqual(['']);
+  });
+
+  test('splits at space when no newlines available', () => {
+    // Words separated by spaces, no newlines
+    const words = Array(200).fill('word').join(' '); // "word word word..." ~1000 chars
+    const result = splitMessage(words, 100);
+    expect(result.length).toBeGreaterThan(1);
+    for (const chunk of result) {
+      expect(chunk.length).toBeLessThanOrEqual(100);
+    }
+  });
+});

package/src/comms/desktop-notify.ts

@@ -0,0 +1,114 @@
+/**
+ * Desktop Notification Sender
+ *
+ * Sends native desktop notifications.
+ * Tries in order:
+ *   1. notify-send (Linux/WSLg)
+ *   2. PowerShell toast (WSL2 → Windows)
+ * Gracefully degrades if neither is available.
+ */
+
+type NotifyMethod = 'notify-send' | 'powershell' | null;
+
+let method: NotifyMethod | undefined;
+
+function detectMethod(): NotifyMethod {
+  if (method !== undefined) return method;
+
+  // Try notify-send first (native Linux/WSLg)
+  try {
+    const result = Bun.spawnSync(['which', 'notify-send']);
+    if (result.exitCode === 0) {
+      method = 'notify-send';
+      console.log('[DesktopNotify] Using notify-send');
+      return method;
+    }
+  } catch { /* continue */ }
+
+  // Try PowerShell (WSL2 → Windows toast)
+  try {
+    const result = Bun.spawnSync(['which', 'powershell.exe']);
+    if (result.exitCode === 0) {
+      method = 'powershell';
+      console.log('[DesktopNotify] Using PowerShell toasts');
+      return method;
+    }
+  } catch { /* continue */ }
+
+  method = null;
+  console.log('[DesktopNotify] No notification method available');
+  return method;
+}
+
+/**
+ * Send a native desktop notification.
+ * Returns true if sent, false if unavailable.
+ */
+export function sendDesktopNotification(
+  title: string,
+  body: string,
+  options?: {
+    urgency?: 'low' | 'normal' | 'critical';
+    expireMs?: number;
+  }
+): boolean {
+  const m = detectMethod();
+  if (!m) return false;
+
+  try {
+    if (m === 'notify-send') {
+      return sendViaNotifySend(title, body, options);
+    } else {
+      return sendViaPowerShell(title, body);
+    }
+  } catch {
+    return false;
+  }
+}
+
+function sendViaNotifySend(
+  title: string,
+  body: string,
+  options?: { urgency?: string; expireMs?: number }
+): boolean {
+  const urgency = options?.urgency ?? 'normal';
+  const expireMs = options?.expireMs ?? (urgency === 'critical' ? 10000 : 5000);
+
+  Bun.spawn([
+    'notify-send',
+    `--urgency=${urgency}`,
+    `--expire-time=${expireMs}`,
+    '--app-name=JARVIS',
+    title,
+    body,
+  ], { stdout: 'ignore', stderr: 'ignore' });
+  return true;
+}
+
+function sendViaPowerShell(title: string, body: string): boolean {
+  // Escape single quotes for PowerShell
+  const safeTitle = title.replace(/'/g, "''").slice(0, 100);
+  const safeBody = body.replace(/'/g, "''").slice(0, 200);
+
+  const script = `
+    [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+    [Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom, ContentType = WindowsRuntime] | Out-Null
+    $xml = [Windows.Data.Xml.Dom.XmlDocument]::new()
+    $xml.LoadXml('<toast><visual><binding template="ToastText02"><text id="1">${safeTitle}</text><text id="2">${safeBody}</text></binding></visual></toast>')
+    $toast = [Windows.UI.Notifications.ToastNotification]::new($xml)
+    [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('JARVIS').Show($toast)
+  `.trim();
+
+  Bun.spawn(['powershell.exe', '-NoProfile', '-NonInteractive', '-Command', script], {
+    stdout: 'ignore',
+    stderr: 'ignore',
+  });
+  return true;
+}
+
+/**
+ * Check if desktop notifications are available.
+ */
+export function isDesktopNotifyAvailable(): boolean {
+  return detectMethod() !== null;
+}