cognova 0.2.2 → 0.2.4

package/server/bridge/adapters/imessage.ts

@@ -0,0 +1,352 @@
+import { spawn, execFile } from 'child_process'
+import type { ChildProcess } from 'child_process'
+import { randomBytes } from 'crypto'
+import type { BridgeAdapter, OutboundMessage, DeliveryResult, NormalizedMessage } from '../types'
+import type { IMessageBridgeConfig } from '~~/shared/types'
+import { getSecretValue } from '~~/server/utils/get-secret'
+import { handleInboundMessage } from '../router'
+
+/**
+ * iMessage adapter with two backends:
+ *
+ * 1. "imsg" — Local macOS only. Spawns `imsg watch --json` as a child process
+ *    for receiving, and `imsg send` for sending. Requires Full Disk Access +
+ *    Automation permissions on the Mac.
+ *
+ * 2. "bluebubbles" — Any platform. Communicates with a BlueBubbles server
+ *    running on a remote Mac via its REST API. Receives via webhook push.
+ */
+export class IMessageAdapter implements BridgeAdapter {
+  readonly platform = 'imessage' as const
+
+  private bridgeId: string
+  private config: IMessageBridgeConfig
+  private healthy = false
+
+  // imsg strategy
+  private watchProcess: ChildProcess | null = null
+
+  // BlueBubbles strategy
+  private bbUrl: string | null = null
+  private bbPassword: string | null = null
+  private webhookSecret: string
+
+  constructor(
+    bridgeId: string,
+    config: IMessageBridgeConfig,
+    webhookSecret?: string
+  ) {
+    this.bridgeId = bridgeId
+    this.config = config
+    this.webhookSecret = webhookSecret || randomBytes(32).toString('hex')
+  }
+
+  get secret(): string {
+    return this.webhookSecret
+  }
+
+  async start(): Promise<void> {
+    if (this.config.strategy === 'imsg')
+      await this.startImsg()
+    else
+      await this.startBlueBubbles()
+  }
+
+  async stop(): Promise<void> {
+    if (this.config.strategy === 'imsg')
+      this.stopImsg()
+    else
+      await this.stopBlueBubbles()
+
+    this.healthy = false
+  }
+
+  async send(msg: OutboundMessage): Promise<DeliveryResult> {
+    if (this.config.strategy === 'imsg')
+      return this.sendImsg(msg)
+    else
+      return this.sendBlueBubbles(msg)
+  }
+
+  isHealthy(): boolean {
+    return this.healthy
+  }
+
+  /**
+   * Handle an incoming BlueBubbles webhook event.
+   * Called by the webhook API route.
+   */
+  async handleWebhook(event: BlueBubblesWebhookEvent): Promise<void> {
+    if (event.type !== 'new-message') return
+
+    const data = event.data
+    if (!data || data.isFromMe) return
+
+    const sender = data.handle?.address || data.handle?.id || 'unknown'
+
+    // Filter by allowed numbers
+    if (this.config.allowedNumbers?.length) {
+      const normalized = sender.replace(/[\s\-()]/g, '')
+      if (!this.config.allowedNumbers.some(n => normalized.includes(n.replace(/[\s\-()]/g, ''))))
+        return
+    }
+
+    const normalized: NormalizedMessage = {
+      platform: 'imessage',
+      sender,
+      senderName: data.handle?.address || sender,
+      text: data.text || '',
+      channelId: data.chatGuid,
+      platformMessageId: data.guid,
+      raw: event
+    }
+
+    if (data.attachments?.length) {
+      normalized.attachments = data.attachments.map((att: BlueBubblesAttachment) => ({
+        type: att.mimeType?.startsWith('image/')
+          ? 'image' as const
+          : att.mimeType?.startsWith('video/')
+            ? 'video' as const
+            : att.mimeType?.startsWith('audio/')
+              ? 'audio' as const
+              : 'file' as const,
+        filename: att.transferName,
+        mimeType: att.mimeType,
+        size: att.totalBytes
+      }))
+    }
+
+    await handleInboundMessage(this.bridgeId, normalized)
+  }
+
+  // ─── imsg strategy ─────────────────────────────
+
+  private async startImsg(): Promise<void> {
+    if (process.platform !== 'darwin') {
+      throw new Error('imsg strategy requires macOS. Use "bluebubbles" on other platforms.')
+    }
+
+    // Verify imsg is installed
+    await new Promise<void>((resolve, reject) => {
+      execFile('which', ['imsg'], (err) => {
+        if (err) reject(new Error('imsg not found. Install with: brew install steipete/tap/imsg'))
+        else resolve()
+      })
+    })
+
+    // Spawn the watcher
+    this.watchProcess = spawn('imsg', ['watch', '--json'], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+
+    let buffer = ''
+    this.watchProcess.stdout?.on('data', (chunk: Buffer) => {
+      buffer += chunk.toString()
+      const lines = buffer.split('\n')
+      buffer = lines.pop() || ''
+
+      for (const line of lines) {
+        if (!line.trim()) continue
+        try {
+          const msg = JSON.parse(line) as ImsgWatchMessage
+          void this.handleImsgMessage(msg).catch((err) => {
+            console.error('[imessage] Error processing imsg message:', err)
+          })
+        } catch {
+          console.warn('[imessage] Failed to parse imsg JSON line:', line.substring(0, 100))
+        }
+      }
+    })
+
+    this.watchProcess.stderr?.on('data', (chunk: Buffer) => {
+      console.error('[imessage] imsg stderr:', chunk.toString().trim())
+    })
+
+    this.watchProcess.on('exit', (code) => {
+      console.log(`[imessage] imsg watch exited with code ${code}`)
+      this.healthy = false
+      this.watchProcess = null
+    })
+
+    this.healthy = true
+    console.log('[imessage] imsg watcher started')
+  }
+
+  private stopImsg(): void {
+    if (this.watchProcess) {
+      this.watchProcess.kill('SIGTERM')
+      this.watchProcess = null
+    }
+    console.log('[imessage] imsg watcher stopped')
+  }
+
+  private async sendImsg(msg: OutboundMessage): Promise<DeliveryResult> {
+    return new Promise((resolve) => {
+      execFile('imsg', ['send', msg.recipient, msg.text], (err, _stdout, stderr) => {
+        if (err) {
+          resolve({ success: false, error: stderr || err.message })
+        } else {
+          resolve({ success: true })
+        }
+      })
+    })
+  }
+
+  private async handleImsgMessage(msg: ImsgWatchMessage): Promise<void> {
+    // Skip our own sent messages
+    if (msg.is_from_me) return
+
+    const sender = msg.sender || msg.chat_id || 'unknown'
+
+    // Filter by allowed numbers
+    if (this.config.allowedNumbers?.length) {
+      const normalized = sender.replace(/[\s\-()]/g, '')
+      if (!this.config.allowedNumbers.some(n => normalized.includes(n.replace(/[\s\-()]/g, ''))))
+        return
+    }
+
+    const normalizedMsg: NormalizedMessage = {
+      platform: 'imessage',
+      sender,
+      senderName: msg.sender_name || sender,
+      text: msg.text || '',
+      channelId: msg.chat_id,
+      platformMessageId: msg.guid,
+      raw: msg
+    }
+
+    await handleInboundMessage(this.bridgeId, normalizedMsg)
+  }
+
+  // ─── BlueBubbles strategy ──────────────────────
+
+  private async startBlueBubbles(): Promise<void> {
+    this.bbUrl = this.config.blueBubblesUrl || await getSecretValue('BLUEBUBBLES_URL')
+    this.bbPassword = await getSecretValue('BLUEBUBBLES_PASSWORD')
+
+    if (!this.bbUrl) {
+      throw new Error('BlueBubbles URL not configured. Set it in bridge config or add BLUEBUBBLES_URL secret.')
+    }
+    if (!this.bbPassword) {
+      throw new Error('BLUEBUBBLES_PASSWORD secret not found. Add it in Settings → Secrets.')
+    }
+
+    // Test connection by pinging the server
+    const pingUrl = `${this.bbUrl}/api/v1/ping?password=${encodeURIComponent(this.bbPassword)}`
+    const pingResp = await fetch(pingUrl)
+    if (!pingResp.ok) {
+      throw new Error(`BlueBubbles server not reachable: ${pingResp.status}`)
+    }
+
+    // Register webhook for incoming messages
+    const webhookUrl = this.getWebhookUrl()
+    if (webhookUrl) {
+      await this.registerBBWebhook(webhookUrl)
+    } else {
+      console.log('[imessage] No webhook URL configured for BlueBubbles — manual setup needed')
+    }
+
+    this.healthy = true
+    console.log(`[imessage] BlueBubbles connected to ${this.bbUrl}`)
+  }
+
+  private async stopBlueBubbles(): Promise<void> {
+    // Best-effort webhook cleanup
+    this.bbUrl = null
+    this.bbPassword = null
+    console.log('[imessage] BlueBubbles disconnected')
+  }
+
+  private async sendBlueBubbles(msg: OutboundMessage): Promise<DeliveryResult> {
+    if (!this.bbUrl || !this.bbPassword) {
+      return { success: false, error: 'BlueBubbles not connected' }
+    }
+
+    try {
+      const resp = await fetch(`${this.bbUrl}/api/v1/message/text?password=${encodeURIComponent(this.bbPassword)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chatGuid: msg.recipient,
+          message: msg.text
+        })
+      })
+
+      if (!resp.ok) {
+        const body = await resp.text()
+        return { success: false, error: `BlueBubbles send failed: ${resp.status} ${body.substring(0, 200)}` }
+      }
+
+      const data = await resp.json() as { data?: { guid?: string } }
+      return {
+        success: true,
+        platformMessageId: data.data?.guid
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      }
+    }
+  }
+
+  private getWebhookUrl(): string | null {
+    const baseUrl = process.env.NUXT_PUBLIC_URL || process.env.APP_URL
+    if (baseUrl)
+      return `${baseUrl.replace(/\/$/, '')}/api/webhooks/bluebubbles`
+    return null
+  }
+
+  private async registerBBWebhook(url: string): Promise<void> {
+    if (!this.bbUrl || !this.bbPassword) return
+
+    try {
+      await fetch(`${this.bbUrl}/api/v1/webhook?password=${encodeURIComponent(this.bbPassword)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          url,
+          events: ['new-message']
+        })
+      })
+      console.log(`[imessage] BlueBubbles webhook registered: ${url}`)
+    } catch (error) {
+      console.warn('[imessage] Failed to register BlueBubbles webhook:', error)
+    }
+  }
+}
+
+// ─── Types ─────────────────────────────────────
+
+interface ImsgWatchMessage {
+  guid?: string
+  text?: string
+  sender?: string
+  sender_name?: string
+  chat_id?: string
+  is_from_me?: boolean
+  date?: string
+}
+
+interface BlueBubblesWebhookEvent {
+  type: string
+  data?: {
+    guid?: string
+    text?: string
+    isFromMe?: boolean
+    chatGuid?: string
+    handle?: {
+      id?: string
+      address?: string
+    }
+    attachments?: BlueBubblesAttachment[]
+  }
+}
+
+interface BlueBubblesAttachment {
+  transferName?: string
+  mimeType?: string
+  totalBytes?: number
+}
+
+export type { BlueBubblesWebhookEvent }

package/server/bridge/adapters/telegram.ts

@@ -0,0 +1,294 @@
+import { randomBytes } from 'crypto'
+import type { BridgeAdapter, OutboundMessage, DeliveryResult, NormalizedMessage } from '../types'
+import type { TelegramBridgeConfig } from '~~/shared/types'
+import { getSecretValue } from '~~/server/utils/get-secret'
+import { handleInboundMessage } from '../router'
+
+const TELEGRAM_API = 'https://api.telegram.org'
+
+/**
+ * Telegram Bot API types (subset of what we need)
+ */
+interface TelegramUpdate {
+  update_id: number
+  message?: TelegramMessage
+  edited_message?: TelegramMessage
+}
+
+interface TelegramMessage {
+  message_id: number
+  from?: {
+    id: number
+    is_bot: boolean
+    first_name: string
+    last_name?: string
+    username?: string
+  }
+  chat: {
+    id: number
+    type: 'private' | 'group' | 'supergroup' | 'channel'
+    title?: string
+    username?: string
+    first_name?: string
+  }
+  date: number
+  text?: string
+  photo?: TelegramPhotoSize[]
+  document?: TelegramDocument
+  caption?: string
+  reply_to_message?: TelegramMessage
+}
+
+interface TelegramPhotoSize {
+  file_id: string
+  file_unique_id: string
+  width: number
+  height: number
+  file_size?: number
+}
+
+interface TelegramDocument {
+  file_id: string
+  file_unique_id: string
+  file_name?: string
+  mime_type?: string
+  file_size?: number
+}
+
+/**
+ * Telegram adapter using the Bot API webhook mode.
+ *
+ * When started, registers a webhook with Telegram so they push updates to us.
+ * When stopped, removes the webhook.
+ * Messages are sent via the Bot API sendMessage endpoint.
+ */
+export class TelegramAdapter implements BridgeAdapter {
+  readonly platform = 'telegram' as const
+
+  private bridgeId: string
+  private config: TelegramBridgeConfig
+  private botToken: string | null = null
+  private webhookSecret: string
+  private healthy = false
+
+  constructor(
+    bridgeId: string,
+    config: TelegramBridgeConfig,
+    webhookSecret?: string
+  ) {
+    this.bridgeId = bridgeId
+    this.config = config
+    this.webhookSecret = webhookSecret || randomBytes(32).toString('hex')
+  }
+
+  get secret(): string {
+    return this.webhookSecret
+  }
+
+  async start(): Promise<void> {
+    // Fetch bot token from secrets store
+    this.botToken = await getSecretValue('TELEGRAM_BOT_TOKEN')
+    if (!this.botToken) {
+      throw new Error('TELEGRAM_BOT_TOKEN secret not found. Add it in Settings → Secrets.')
+    }
+
+    // Validate token by calling getMe
+    const me = await this.apiCall('getMe')
+    if (!me.ok) {
+      throw new Error(`Invalid Telegram bot token: ${me.description || 'unknown error'}`)
+    }
+
+    // Store bot username if not set
+    if (!this.config.botUsername && me.result?.username) {
+      this.config.botUsername = me.result.username
+    }
+
+    console.log(`[telegram] Bot @${me.result?.username} authenticated`)
+
+    // Register webhook
+    const webhookUrl = this.getWebhookUrl()
+    if (webhookUrl) {
+      const setResult = await this.apiCall('setWebhook', {
+        url: webhookUrl,
+        secret_token: this.webhookSecret,
+        allowed_updates: ['message', 'edited_message']
+      })
+
+      if (!setResult.ok) {
+        throw new Error(`Failed to set webhook: ${setResult.description || 'unknown error'}`)
+      }
+
+      console.log(`[telegram] Webhook registered: ${webhookUrl}`)
+    } else {
+      console.log('[telegram] No webhook URL configured — using polling or manual webhook setup')
+    }
+
+    this.healthy = true
+  }
+
+  async stop(): Promise<void> {
+    if (this.botToken) {
+      try {
+        await this.apiCall('deleteWebhook')
+        console.log('[telegram] Webhook removed')
+      } catch {
+        // Best effort — don't fail shutdown
+      }
+    }
+    this.healthy = false
+    this.botToken = null
+  }
+
+  async send(msg: OutboundMessage): Promise<DeliveryResult> {
+    if (!this.botToken) {
+      return { success: false, error: 'Bot token not available' }
+    }
+
+    try {
+      const result = await this.apiCall('sendMessage', {
+        chat_id: msg.recipient,
+        text: msg.text,
+        parse_mode: 'Markdown',
+        ...(msg.replyToMessageId && {
+          reply_parameters: { message_id: parseInt(msg.replyToMessageId) }
+        })
+      })
+
+      if (!result.ok) {
+        return { success: false, error: result.description || 'Send failed' }
+      }
+
+      return {
+        success: true,
+        platformMessageId: String(result.result?.message_id)
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown send error'
+      }
+    }
+  }
+
+  isHealthy(): boolean {
+    return this.healthy
+  }
+
+  /**
+   * Handle an incoming webhook update from Telegram.
+   * Called by the webhook API route after header verification.
+   */
+  async handleUpdate(update: TelegramUpdate): Promise<void> {
+    const message = update.message || update.edited_message
+    if (!message) return
+
+    // Skip bot messages
+    if (message.from?.is_bot) return
+
+    // If allowedChatIds is configured, filter
+    if (this.config.allowedChatIds?.length) {
+      if (!this.config.allowedChatIds.includes(String(message.chat.id)))
+        return
+    }
+
+    const text = message.text || message.caption || ''
+    if (!text) return
+
+    const normalized: NormalizedMessage = {
+      platform: 'telegram',
+      sender: String(message.from?.id || message.chat.id),
+      senderName: formatTelegramName(message.from),
+      text,
+      channelId: String(message.chat.id),
+      platformMessageId: String(message.message_id),
+      replyTo: message.reply_to_message
+        ? String(message.reply_to_message.message_id)
+        : undefined,
+      raw: update
+    }
+
+    // Handle photo attachments
+    if (message.photo?.length) {
+      const largest = message.photo[message.photo.length - 1]
+      normalized.attachments = [{
+        type: 'image',
+        filename: `photo_${largest!.file_unique_id}.jpg`,
+        url: await this.getFileUrl(largest!.file_id)
+      }]
+    }
+
+    // Handle document attachments
+    if (message.document) {
+      normalized.attachments = [{
+        type: 'file',
+        filename: message.document.file_name,
+        mimeType: message.document.mime_type,
+        size: message.document.file_size,
+        url: await this.getFileUrl(message.document.file_id)
+      }]
+    }
+
+    await handleInboundMessage(this.bridgeId, normalized)
+  }
+
+  /**
+   * Verify the X-Telegram-Bot-Api-Secret-Token header.
+   */
+  verifySecret(headerValue: string | undefined): boolean {
+    return headerValue === this.webhookSecret
+  }
+
+  // ─── Private helpers ───────────────────────────
+
+  private getWebhookUrl(): string | null {
+    // Check for explicit webhook URL in config
+    const config = this.config as TelegramBridgeConfig & { webhookUrl?: string }
+    if (config.webhookUrl) return config.webhookUrl
+
+    // Check environment variable
+    const baseUrl = process.env.NUXT_PUBLIC_URL || process.env.APP_URL
+    if (baseUrl)
+      return `${baseUrl.replace(/\/$/, '')}/api/webhooks/telegram`
+
+    return null
+  }
+
+  private async apiCall(method: string, body?: Record<string, unknown>): Promise<TelegramApiResponse> {
+    const url = `${TELEGRAM_API}/bot${this.botToken}/${method}`
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: body ? JSON.stringify(body) : undefined
+      })
+
+      return await response.json() as TelegramApiResponse
+    } catch (error) {
+      return {
+        ok: false,
+        description: error instanceof Error ? error.message : 'Network error'
+      }
+    }
+  }
+
+  private async getFileUrl(fileId: string): Promise<string | undefined> {
+    const result = await this.apiCall('getFile', { file_id: fileId })
+    if (result.ok && result.result?.file_path)
+      return `${TELEGRAM_API}/file/bot${this.botToken}/${result.result.file_path}`
+    return undefined
+  }
+}
+
+interface TelegramApiResponse {
+  ok: boolean
+  description?: string
+  result?: Record<string, unknown>
+}
+
+function formatTelegramName(from?: TelegramMessage['from']): string {
+  if (!from) return 'Unknown'
+  const parts = [from.first_name]
+  if (from.last_name) parts.push(from.last_name)
+  return parts.join(' ')
+}