@plosson/agentio 0.4.2 → 0.4.3

package/src/config/config-manager.ts

@@ -7,7 +7,7 @@ import type { Config, ServiceName } from '../types/config';
 const CONFIG_DIR = join(homedir(), '.config', 'agentio');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 
-const ALL_SERVICES: ServiceName[] = ['gdocs', 'gdrive', 'gmail', 'gchat', 'github', 'jira', 'slack', 'telegram', 'discourse', 'sql'];
+const ALL_SERVICES: ServiceName[] = ['gdocs', 'gdrive', 'gmail', 'gchat', 'github', 'jira', 'slack', 'telegram', 'whatsapp', 'discourse', 'sql'];
 
 const DEFAULT_CONFIG: Config = {
   profiles: {},

package/src/gateway/adapters/telegram.ts

@@ -0,0 +1,357 @@
+import type { TelegramCredentials } from '../../types/telegram';
+import type { ServiceName } from '../../types/config';
+import { BaseAdapter, type AdapterInboundMessage, type AdapterOutboundMessage, type SendResult } from './types';
+
+const TELEGRAM_API_BASE = 'https://api.telegram.org/bot';
+const LONG_POLL_TIMEOUT = 30; // seconds
+
+interface TelegramApiResponse<T> {
+  ok: boolean;
+  result?: T;
+  description?: string;
+  error_code?: number;
+}
+
+interface TelegramUpdate {
+  update_id: number;
+  message?: TelegramMessageObject;
+  edited_message?: TelegramMessageObject;
+  channel_post?: TelegramMessageObject;
+  edited_channel_post?: TelegramMessageObject;
+}
+
+interface TelegramMessageObject {
+  message_id: number;
+  from?: {
+    id: number;
+    is_bot: boolean;
+    first_name: string;
+    last_name?: string;
+    username?: string;
+  };
+  sender_chat?: {
+    id: number;
+    type: string;
+    title?: string;
+    username?: string;
+  };
+  chat: {
+    id: number;
+    type: 'private' | 'group' | 'supergroup' | 'channel';
+    title?: string;
+    username?: string;
+    first_name?: string;
+    last_name?: string;
+  };
+  date: number;
+  text?: string;
+  photo?: TelegramPhotoSize[];
+  video?: TelegramVideo;
+  audio?: TelegramAudio;
+  document?: TelegramDocument;
+  voice?: TelegramVoice;
+  reply_to_message?: TelegramMessageObject;
+}
+
+interface TelegramPhotoSize {
+  file_id: string;
+  file_unique_id: string;
+  width: number;
+  height: number;
+  file_size?: number;
+}
+
+interface TelegramVideo {
+  file_id: string;
+  file_unique_id: string;
+  width: number;
+  height: number;
+  duration: number;
+  file_size?: number;
+}
+
+interface TelegramAudio {
+  file_id: string;
+  file_unique_id: string;
+  duration: number;
+  file_size?: number;
+}
+
+interface TelegramDocument {
+  file_id: string;
+  file_unique_id: string;
+  file_name?: string;
+  file_size?: number;
+}
+
+interface TelegramVoice {
+  file_id: string;
+  file_unique_id: string;
+  duration: number;
+  file_size?: number;
+}
+
+interface ProfileConnection {
+  credentials: TelegramCredentials;
+  lastUpdateId: number;
+  abortController: AbortController | null;
+  pollPromise: Promise<void> | null;
+  shouldStop: boolean;
+}
+
+export class TelegramAdapter extends BaseAdapter {
+  readonly service: ServiceName = 'telegram';
+
+  private profiles: Map<string, ProfileConnection> = new Map();
+
+  async connect(profile: string, credentials: unknown): Promise<void> {
+    const creds = credentials as TelegramCredentials;
+
+    // Stop existing connection if any
+    await this.disconnect(profile);
+
+    const connection: ProfileConnection = {
+      credentials: creds,
+      lastUpdateId: 0,
+      abortController: null,
+      pollPromise: null,
+      shouldStop: false,
+    };
+
+    this.profiles.set(profile, connection);
+
+    // Validate credentials first
+    try {
+      const baseUrl = `${TELEGRAM_API_BASE}${creds.botToken}`;
+      const response = await fetch(`${baseUrl}/getMe`);
+      const data = (await response.json()) as TelegramApiResponse<unknown>;
+
+      if (!data.ok) {
+        throw new Error(data.description || 'Invalid bot token');
+      }
+
+      this.setConnected(profile, true);
+      console.log(`[telegram] Connected profile: ${profile}`);
+
+      // Start long-polling
+      this.startPolling(profile);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Connection failed';
+      this.setConnected(profile, false, message);
+      this.profiles.delete(profile);
+      throw error;
+    }
+  }
+
+  async disconnect(profile: string): Promise<void> {
+    const connection = this.profiles.get(profile);
+    if (!connection) return;
+
+    connection.shouldStop = true;
+
+    // Abort any pending request
+    if (connection.abortController) {
+      connection.abortController.abort();
+    }
+
+    // Wait for poll to finish
+    if (connection.pollPromise) {
+      try {
+        await connection.pollPromise;
+      } catch {
+        // Ignore abort errors
+      }
+    }
+
+    this.profiles.delete(profile);
+    this.connections.delete(profile);
+    console.log(`[telegram] Disconnected profile: ${profile}`);
+  }
+
+  async disconnectAll(): Promise<void> {
+    const profiles = Array.from(this.profiles.keys());
+    await Promise.all(profiles.map((p) => this.disconnect(p)));
+  }
+
+  async send(profile: string, message: AdapterOutboundMessage): Promise<SendResult> {
+    const connection = this.profiles.get(profile);
+    if (!connection) {
+      return { success: false, error: 'Profile not connected' };
+    }
+
+    const baseUrl = `${TELEGRAM_API_BASE}${connection.credentials.botToken}`;
+
+    try {
+      // Handle media if present
+      if (message.mediaPath) {
+        // For now, only support sending text
+        // Media sending would require multipart form upload
+        return { success: false, error: 'Media sending not yet implemented' };
+      }
+
+      const params: Record<string, unknown> = {
+        chat_id: message.conversationId,
+        text: message.content || '',
+      };
+
+      // Add reply reference if present
+      if (message.replyToPlatformId) {
+        params.reply_to_message_id = parseInt(message.replyToPlatformId, 10);
+      }
+
+      // Add parse mode from metadata
+      if (message.metadata?.parse_mode) {
+        params.parse_mode = message.metadata.parse_mode;
+      }
+
+      const response = await fetch(`${baseUrl}/sendMessage`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(params),
+      });
+
+      const data = (await response.json()) as TelegramApiResponse<TelegramMessageObject>;
+
+      if (!data.ok) {
+        return { success: false, error: data.description || 'Send failed' };
+      }
+
+      return {
+        success: true,
+        platformId: data.result!.message_id.toString(),
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  private startPolling(profile: string): void {
+    const connection = this.profiles.get(profile);
+    if (!connection || connection.shouldStop) return;
+
+    connection.pollPromise = this.poll(profile);
+  }
+
+  private async poll(profile: string): Promise<void> {
+    const connection = this.profiles.get(profile);
+    if (!connection) return;
+
+    while (!connection.shouldStop) {
+      try {
+        connection.abortController = new AbortController();
+
+        const baseUrl = `${TELEGRAM_API_BASE}${connection.credentials.botToken}`;
+        const params = new URLSearchParams({
+          timeout: LONG_POLL_TIMEOUT.toString(),
+          allowed_updates: JSON.stringify(['message', 'channel_post']),
+        });
+
+        if (connection.lastUpdateId > 0) {
+          params.set('offset', (connection.lastUpdateId + 1).toString());
+        }
+
+        const response = await fetch(`${baseUrl}/getUpdates?${params}`, {
+          signal: connection.abortController.signal,
+        });
+
+        const data = (await response.json()) as TelegramApiResponse<TelegramUpdate[]>;
+
+        if (!data.ok) {
+          console.error(`[telegram:${profile}] Poll error: ${data.description}`);
+          this.setConnected(profile, false, data.description);
+          await this.sleep(5000); // Wait before retry
+          continue;
+        }
+
+        this.setConnected(profile, true);
+
+        const updates = data.result || [];
+        for (const update of updates) {
+          connection.lastUpdateId = Math.max(connection.lastUpdateId, update.update_id);
+          this.processUpdate(profile, update);
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+          break; // Normal shutdown
+        }
+
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`[telegram:${profile}] Poll error: ${message}`);
+        this.setConnected(profile, false, message);
+        await this.sleep(5000); // Wait before retry
+      }
+    }
+  }
+
+  private processUpdate(profile: string, update: TelegramUpdate): void {
+    // Handle regular messages and channel posts
+    const msg = update.message || update.channel_post;
+    if (!msg) return;
+
+    // Determine sender info
+    let senderId: string;
+    let senderName: string | undefined;
+    let senderHandle: string | undefined;
+
+    if (msg.from) {
+      senderId = msg.from.id.toString();
+      senderName = [msg.from.first_name, msg.from.last_name].filter(Boolean).join(' ');
+      senderHandle = msg.from.username;
+    } else if (msg.sender_chat) {
+      senderId = msg.sender_chat.id.toString();
+      senderName = msg.sender_chat.title;
+      senderHandle = msg.sender_chat.username;
+    } else {
+      senderId = msg.chat.id.toString();
+      senderName = msg.chat.title || msg.chat.first_name;
+      senderHandle = msg.chat.username;
+    }
+
+    // Determine media type
+    let mediaType: AdapterInboundMessage['mediaType'];
+    let mediaUrl: string | undefined;
+
+    if (msg.photo && msg.photo.length > 0) {
+      mediaType = 'image';
+      // Get largest photo
+      const largestPhoto = msg.photo.reduce((a, b) =>
+        (a.file_size || 0) > (b.file_size || 0) ? a : b
+      );
+      mediaUrl = largestPhoto.file_id; // File ID, needs getFile call to download
+    } else if (msg.video) {
+      mediaType = 'video';
+      mediaUrl = msg.video.file_id;
+    } else if (msg.audio || msg.voice) {
+      mediaType = 'audio';
+      mediaUrl = (msg.audio || msg.voice)?.file_id;
+    } else if (msg.document) {
+      mediaType = 'document';
+      mediaUrl = msg.document.file_id;
+    }
+
+    const inboundMessage: AdapterInboundMessage = {
+      conversationId: msg.chat.id.toString(),
+      platformId: msg.message_id.toString(),
+      senderId,
+      senderName,
+      senderHandle,
+      content: msg.text,
+      mediaType,
+      mediaUrl,
+      receivedAt: msg.date * 1000, // Convert to milliseconds
+      replyToId: msg.reply_to_message?.message_id.toString(),
+      metadata: {
+        chatType: msg.chat.type,
+        chatTitle: msg.chat.title,
+        updateId: update.update_id,
+      },
+    };
+
+    this.emitMessage(profile, inboundMessage);
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/gateway/adapters/types.ts

@@ -0,0 +1,147 @@
+import type { ServiceName } from '../../types/config';
+import type { InboundMessage, OutboundMessage, MediaType } from '../types';
+
+/**
+ * Result from sending a message through an adapter
+ */
+export interface SendResult {
+  success: boolean;
+  platformId?: string;
+  error?: string;
+}
+
+/**
+ * Inbound message data from an adapter (before DB insert)
+ */
+export interface AdapterInboundMessage {
+  conversationId: string;
+  platformId: string;
+  senderId: string;
+  senderName?: string;
+  senderHandle?: string;
+  content?: string;
+  mediaType?: MediaType;
+  mediaUrl?: string;        // URL for downloading media
+  receivedAt: number;
+  replyToId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Outbound message data for an adapter
+ */
+export interface AdapterOutboundMessage {
+  conversationId: string;
+  content?: string;
+  mediaPath?: string;
+  mediaType?: MediaType;
+  replyToPlatformId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Connection state for a profile
+ */
+export interface ConnectionState {
+  connected: boolean;
+  error?: string;
+  lastError?: Date;
+  reconnectAttempts?: number;
+}
+
+/**
+ * Service adapter interface
+ * Each service implements this to handle inbound/outbound messages
+ */
+export interface ServiceAdapter {
+  /**
+   * The service this adapter handles
+   */
+  readonly service: ServiceName;
+
+  /**
+   * Connect to the service for a specific profile
+   */
+  connect(profile: string, credentials: unknown): Promise<void>;
+
+  /**
+   * Disconnect a specific profile
+   */
+  disconnect(profile: string): Promise<void>;
+
+  /**
+   * Disconnect all profiles
+   */
+  disconnectAll(): Promise<void>;
+
+  /**
+   * Check if a profile is connected
+   */
+  isConnected(profile: string): boolean;
+
+  /**
+   * Get connection state for a profile
+   */
+  getConnectionState(profile: string): ConnectionState;
+
+  /**
+   * Get all connected profiles
+   */
+  getConnectedProfiles(): string[];
+
+  /**
+   * Send a message through the adapter
+   */
+  send(profile: string, message: AdapterOutboundMessage): Promise<SendResult>;
+
+  /**
+   * Callback for when a message is received
+   * Set by the gateway to handle inbound messages
+   */
+  onMessage: ((profile: string, message: AdapterInboundMessage) => void) | null;
+}
+
+/**
+ * Base class for service adapters with common functionality
+ */
+export abstract class BaseAdapter implements ServiceAdapter {
+  abstract readonly service: ServiceName;
+
+  protected connections: Map<string, ConnectionState> = new Map();
+  public onMessage: ((profile: string, message: AdapterInboundMessage) => void) | null = null;
+
+  isConnected(profile: string): boolean {
+    return this.connections.get(profile)?.connected ?? false;
+  }
+
+  getConnectionState(profile: string): ConnectionState {
+    return this.connections.get(profile) ?? { connected: false };
+  }
+
+  getConnectedProfiles(): string[] {
+    return Array.from(this.connections.entries())
+      .filter(([_, state]) => state.connected)
+      .map(([profile]) => profile);
+  }
+
+  protected setConnected(profile: string, connected: boolean, error?: string): void {
+    const current = this.connections.get(profile) ?? { connected: false };
+    this.connections.set(profile, {
+      ...current,
+      connected,
+      error: connected ? undefined : error,
+      lastError: error ? new Date() : current.lastError,
+    });
+  }
+
+  protected emitMessage(profile: string, message: AdapterInboundMessage): void {
+    if (this.onMessage) {
+      this.onMessage(profile, message);
+    }
+  }
+
+  abstract connect(profile: string, credentials: unknown): Promise<void>;
+  abstract disconnect(profile: string): Promise<void>;
+  abstract disconnectAll(): Promise<void>;
+  abstract send(profile: string, message: AdapterOutboundMessage): Promise<SendResult>;
+}

package/src/gateway/adapters/whatsapp-auth.ts

@@ -0,0 +1,172 @@
+/**
+ * SQLite-based auth state store for Baileys
+ * Implements the AuthenticationState interface required by Baileys
+ */
+import type { AuthenticationCreds, AuthenticationState, SignalDataTypeMap } from '@whiskeysockets/baileys';
+import { proto } from '@whiskeysockets/baileys';
+import { initAuthCreds, BufferJSON } from '@whiskeysockets/baileys';
+import { getDatabase } from '../store';
+
+interface AuthCredsRow {
+  profile: string;
+  data: string;
+  updated_at: number;
+}
+
+interface AuthKeyRow {
+  profile: string;
+  type: string;
+  key_id: string;
+  data: string;
+}
+
+/**
+ * Create a SQLite-based auth state for Baileys
+ */
+export async function useSQLiteAuthState(profile: string): Promise<{
+  state: AuthenticationState;
+  saveCreds: () => Promise<void>;
+  clearState: () => Promise<void>;
+}> {
+  const db = getDatabase();
+
+  // Load or initialize credentials
+  const loadCreds = (): AuthenticationCreds => {
+    const row = db.query<AuthCredsRow, [string]>(
+      'SELECT data FROM whatsapp_auth_creds WHERE profile = ?'
+    ).get(profile);
+
+    if (row) {
+      return JSON.parse(row.data, BufferJSON.reviver);
+    }
+
+    // Initialize new credentials
+    return initAuthCreds();
+  };
+
+  // Save credentials
+  const saveCreds = async (): Promise<void> => {
+    const data = JSON.stringify(creds, BufferJSON.replacer);
+    db.run(
+      `INSERT OR REPLACE INTO whatsapp_auth_creds (profile, data, updated_at)
+       VALUES (?, ?, ?)`,
+      [profile, data, Date.now()]
+    );
+  };
+
+  // Clear all auth state for this profile
+  const clearState = async (): Promise<void> => {
+    db.run('DELETE FROM whatsapp_auth_creds WHERE profile = ?', [profile]);
+    db.run('DELETE FROM whatsapp_auth_keys WHERE profile = ?', [profile]);
+  };
+
+  // Read keys from database
+  const readData = <T>(type: string, ids: string[]): { [id: string]: T } => {
+    const result: { [id: string]: T } = {};
+
+    if (ids.length === 0) return result;
+
+    // Build query with placeholders
+    const placeholders = ids.map(() => '?').join(', ');
+    const rows = db.query<AuthKeyRow, string[]>(
+      `SELECT key_id, data FROM whatsapp_auth_keys
+       WHERE profile = ? AND type = ? AND key_id IN (${placeholders})`
+    ).all(profile, type, ...ids);
+
+    for (const row of rows) {
+      try {
+        result[row.key_id] = JSON.parse(row.data, BufferJSON.reviver);
+      } catch {
+        // Skip invalid data
+      }
+    }
+
+    return result;
+  };
+
+  // Write keys to database
+  const writeData = <T>(type: string, data: { [id: string]: T }): void => {
+    const stmt = db.prepare(
+      `INSERT OR REPLACE INTO whatsapp_auth_keys (profile, type, key_id, data)
+       VALUES (?, ?, ?, ?)`
+    );
+
+    for (const [id, value] of Object.entries(data)) {
+      if (value !== null && value !== undefined) {
+        stmt.run(profile, type, id, JSON.stringify(value, BufferJSON.replacer));
+      }
+    }
+  };
+
+  // Delete keys from database
+  const removeData = (type: string, ids: string[]): void => {
+    if (ids.length === 0) return;
+
+    const placeholders = ids.map(() => '?').join(', ');
+    db.run(
+      `DELETE FROM whatsapp_auth_keys
+       WHERE profile = ? AND type = ? AND key_id IN (${placeholders})`,
+      [profile, type, ...ids]
+    );
+  };
+
+  const creds = loadCreds();
+
+  const state: AuthenticationState = {
+    creds,
+    keys: {
+      get: <T extends keyof SignalDataTypeMap>(type: T, ids: string[]): { [id: string]: SignalDataTypeMap[T] } => {
+        return readData<SignalDataTypeMap[T]>(type, ids);
+      },
+      set: (data: { [T in keyof SignalDataTypeMap]?: { [id: string]: SignalDataTypeMap[T] | null } }): void => {
+        for (const [type, typeData] of Object.entries(data)) {
+          if (!typeData) continue;
+
+          const toWrite: { [id: string]: unknown } = {};
+          const toDelete: string[] = [];
+
+          for (const [id, value] of Object.entries(typeData)) {
+            if (value === null || value === undefined) {
+              toDelete.push(id);
+            } else {
+              toWrite[id] = value;
+            }
+          }
+
+          if (Object.keys(toWrite).length > 0) {
+            writeData(type, toWrite);
+          }
+          if (toDelete.length > 0) {
+            removeData(type, toDelete);
+          }
+        }
+      },
+    },
+  };
+
+  return {
+    state,
+    saveCreds,
+    clearState,
+  };
+}
+
+/**
+ * Check if a profile has existing auth state
+ */
+export function hasAuthState(profile: string): boolean {
+  const db = getDatabase();
+  const row = db.query<{ count: number }, [string]>(
+    'SELECT COUNT(*) as count FROM whatsapp_auth_creds WHERE profile = ?'
+  ).get(profile);
+  return (row?.count ?? 0) > 0;
+}
+
+/**
+ * Delete auth state for a profile
+ */
+export function deleteAuthState(profile: string): void {
+  const db = getDatabase();
+  db.run('DELETE FROM whatsapp_auth_creds WHERE profile = ?', [profile]);
+  db.run('DELETE FROM whatsapp_auth_keys WHERE profile = ?', [profile]);
+}