agent-messenger 1.15.0 → 2.1.0

package/src/platforms/teams/index.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from 'bun:test'
+
+import {
+  TeamsAccountSchema,
+  TeamsAccountTypeSchema,
+  TeamsChannelSchema,
+  TeamsClient,
+  TeamsConfigLegacySchema,
+  TeamsConfigSchema,
+  TeamsCredentialManager,
+  TeamsCredentialsSchema,
+  TeamsError,
+  TeamsFileSchema,
+  TeamsMessageSchema,
+  TeamsReactionSchema,
+  TeamsTeamSchema,
+  TeamsUserSchema,
+} from '@/platforms/teams/index'
+
+test('TeamsClient is exported from barrel', () => {
+  expect(typeof TeamsClient).toBe('function')
+})
+
+test('TeamsError is exported from barrel', () => {
+  expect(typeof TeamsError).toBe('function')
+})
+
+test('TeamsCredentialManager is exported from barrel', () => {
+  expect(typeof TeamsCredentialManager).toBe('function')
+})
+
+test('TeamsTeamSchema is exported from barrel', () => {
+  expect(typeof TeamsTeamSchema.parse).toBe('function')
+})
+
+test('TeamsChannelSchema is exported from barrel', () => {
+  expect(typeof TeamsChannelSchema.parse).toBe('function')
+})
+
+test('TeamsMessageSchema is exported from barrel', () => {
+  expect(typeof TeamsMessageSchema.parse).toBe('function')
+})
+
+test('TeamsUserSchema is exported from barrel', () => {
+  expect(typeof TeamsUserSchema.parse).toBe('function')
+})
+
+test('TeamsReactionSchema is exported from barrel', () => {
+  expect(typeof TeamsReactionSchema.parse).toBe('function')
+})
+
+test('TeamsFileSchema is exported from barrel', () => {
+  expect(typeof TeamsFileSchema.parse).toBe('function')
+})
+
+test('TeamsCredentialsSchema is exported from barrel', () => {
+  expect(typeof TeamsCredentialsSchema.parse).toBe('function')
+})
+
+test('TeamsAccountTypeSchema is exported from barrel', () => {
+  expect(typeof TeamsAccountTypeSchema.parse).toBe('function')
+})
+
+test('TeamsAccountSchema is exported from barrel', () => {
+  expect(typeof TeamsAccountSchema.parse).toBe('function')
+})
+
+test('TeamsConfigSchema is exported from barrel', () => {
+  expect(typeof TeamsConfigSchema.parse).toBe('function')
+})
+
+test('TeamsConfigLegacySchema is exported from barrel', () => {
+  expect(typeof TeamsConfigLegacySchema.parse).toBe('function')
+})

package/src/platforms/teams/index.ts

@@ -0,0 +1,30 @@
+export { TeamsClient } from './client'
+export { TeamsCredentialManager } from './credential-manager'
+export { TeamsError } from './types'
+export type {
+  TeamsAccount,
+  TeamsAccountType,
+  TeamsChannel,
+  TeamsConfig,
+  TeamsConfigLegacy,
+  TeamsCredentials,
+  TeamsFile,
+  TeamsMessage,
+  TeamsReaction,
+  TeamsTeam,
+  TeamsUser,
+} from './types'
+export {
+  TeamsAccountSchema,
+  TeamsAccountTypeSchema,
+  TeamsChannelSchema,
+  TeamsConfigLegacySchema,
+  TeamsConfigSchema,
+  TeamsCredentialsSchema,
+  TeamsFileSchema,
+  TeamsMessageSchema,
+  TeamsReactionSchema,
+  TeamsTeamSchema,
+  TeamsUserSchema,
+} from './types'
+

package/src/platforms/telegram/app-config.test.ts

@@ -0,0 +1,44 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { getTelegramAppCredentials } from './app-config'
+
+const ENV_KEYS = [
+  'AGENT_TELEGRAM_API_ID',
+  'AGENT_TELEGRAM_API_HASH',
+  'AGENT_MESSENGER_TELEGRAM_API_ID',
+  'AGENT_MESSENGER_TELEGRAM_API_HASH',
+] as const
+
+describe('telegram app config', () => {
+  beforeEach(() => {
+    for (const key of ENV_KEYS) {
+      delete process.env[key]
+    }
+  })
+
+  test('returns env credentials when provided', () => {
+    process.env.AGENT_TELEGRAM_API_ID = '12345'
+    process.env.AGENT_TELEGRAM_API_HASH = 'secret'
+
+    expect(getTelegramAppCredentials()).toEqual({
+      api_id: 12345,
+      api_hash: 'secret',
+      source: 'env',
+    })
+  })
+
+  test('returns none when nothing is configured', () => {
+    expect(getTelegramAppCredentials()).toEqual({ source: 'none' })
+  })
+
+  test('rejects malformed api_id like "123abc"', () => {
+    const prev = process.env.AGENT_TELEGRAM_API_ID
+    process.env.AGENT_TELEGRAM_API_ID = '123abc'
+    process.env.AGENT_TELEGRAM_API_HASH = 'abc123'
+    const result = getTelegramAppCredentials()
+    expect(result.source).toBe('none')
+    if (prev === undefined) {
+      delete process.env.AGENT_TELEGRAM_API_ID
+      delete process.env.AGENT_TELEGRAM_API_HASH
+    }
+  })
+})

package/src/platforms/telegram/app-config.ts

@@ -0,0 +1,53 @@
+export interface TelegramAppCredentials {
+  api_id?: number
+  api_hash?: string
+  source: 'env' | 'none'
+}
+
+function parseApiId(value: number | string | undefined): number | undefined {
+  if (value === undefined || value === null || value === '') {
+    return undefined
+  }
+
+  if (typeof value === 'number') {
+    return Number.isInteger(value) && value > 0 ? value : undefined
+  }
+
+  if (!/^\d+$/.test(value)) {
+    return undefined
+  }
+
+  const parsed = Number.parseInt(value, 10)
+  return parsed > 0 ? parsed : undefined
+}
+
+function parseApiHash(value: string | undefined): string | undefined {
+  const normalized = value?.trim()
+  return normalized ? normalized : undefined
+}
+
+export function getTelegramAppCredentials(): TelegramAppCredentials {
+  const envApiId = parseApiId(process.env.AGENT_TELEGRAM_API_ID)
+  const envApiHash = parseApiHash(process.env.AGENT_TELEGRAM_API_HASH)
+
+  if (envApiId && envApiHash) {
+    return {
+      api_id: envApiId,
+      api_hash: envApiHash,
+      source: 'env',
+    }
+  }
+
+  const legacyApiId = parseApiId(process.env.AGENT_MESSENGER_TELEGRAM_API_ID)
+  const legacyApiHash = parseApiHash(process.env.AGENT_MESSENGER_TELEGRAM_API_HASH)
+
+  if (legacyApiId && legacyApiHash) {
+    return {
+      api_id: legacyApiId,
+      api_hash: legacyApiHash,
+      source: 'env',
+    }
+  }
+
+  return { source: 'none' }
+}

package/src/platforms/telegram/chat-utils.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test'
+import { findFuzzyChats, mergeChats, normalizeChatSearchText } from './chat-utils'
+
+describe('normalizeChatSearchText', () => {
+  test('lowercases and strips spaces', () => {
+    expect(normalizeChatSearchText('Hello World')).toBe('helloworld')
+  })
+
+  test('strips special chars', () => {
+    expect(normalizeChatSearchText('ops-alerts!')).toBe('opsalerts')
+  })
+
+  test('handles empty string', () => {
+    expect(normalizeChatSearchText('')).toBe('')
+  })
+
+  test('preserves unicode letters and digits', () => {
+    const result = normalizeChatSearchText('안녕 World 123')
+    expect(result).toContain('안녕')
+    expect(result).toContain('world')
+    expect(result).toContain('123')
+  })
+})
+
+describe('findFuzzyChats', () => {
+  const chats = [
+    { id: 1, title: 'OPS Alerts', type: 'supergroup' },
+    { id: 2, title: 'Engineering', type: 'supergroup' },
+    { id: 3, title: 'ops-team', type: 'group' },
+  ] as any[]
+
+  test('finds partial matches case-insensitively', () => {
+    const result = findFuzzyChats(chats, 'ops', 10)
+    expect(result.map((c) => c.id)).toContain(1)
+    expect(result.map((c) => c.id)).toContain(3)
+  })
+
+  test('returns empty for no matches', () => {
+    expect(findFuzzyChats(chats, 'zzz', 10)).toHaveLength(0)
+  })
+
+  test('returns empty for empty query', () => {
+    expect(findFuzzyChats(chats, '', 10)).toHaveLength(0)
+  })
+
+  test('respects limit', () => {
+    const result = findFuzzyChats(chats, 'o', 1)
+    expect(result).toHaveLength(1)
+  })
+
+  test('does not match chats with empty normalized title', () => {
+    const chats = [{ id: 99, title: '---', type: 'group' }] as any[]
+    expect(findFuzzyChats(chats, 'ops', 10)).toHaveLength(0)
+  })
+})
+
+describe('mergeChats', () => {
+  const a = [{ id: 1, title: 'A', type: 'group' }] as any[]
+  const b = [{ id: 1, title: 'A', type: 'group' }, { id: 2, title: 'B', type: 'group' }] as any[]
+
+  test('deduplicates by id', () => {
+    const result = mergeChats(a, b)
+    expect(result).toHaveLength(2)
+    expect(result.map((c) => c.id)).toEqual([1, 2])
+  })
+
+  test('primary takes precedence order', () => {
+    const result = mergeChats(a, b)
+    expect(result[0].id).toBe(1)
+  })
+})

package/src/platforms/telegram/chat-utils.ts

@@ -0,0 +1,39 @@
+import type { TelegramChatSummary } from './types'
+
+export function normalizeChatSearchText(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/\s+/g, '')
+    .replace(/[^\p{L}\p{N}]+/gu, '')
+}
+
+export function findFuzzyChats(chats: TelegramChatSummary[], query: string, limit: number): TelegramChatSummary[] {
+  const normalizedQuery = normalizeChatSearchText(query)
+  if (!normalizedQuery) {
+    return []
+  }
+
+  return chats
+    .filter((chat) => {
+      const normalizedTitle = normalizeChatSearchText(chat.title)
+      if (!normalizedTitle) return false
+      return normalizedTitle.includes(normalizedQuery) || normalizedQuery.includes(normalizedTitle)
+    })
+    .slice(0, limit)
+}
+
+export function mergeChats(primary: TelegramChatSummary[], secondary: TelegramChatSummary[]): TelegramChatSummary[] {
+  const seen = new Set<number>()
+  const merged: TelegramChatSummary[] = []
+
+  for (const chat of [...primary, ...secondary]) {
+    if (seen.has(chat.id)) {
+      continue
+    }
+
+    seen.add(chat.id)
+    merged.push(chat)
+  }
+
+  return merged
+}

package/src/platforms/telegram/cli.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import pkg from '../../../package.json' with { type: 'json' }
+import { authCommand, chatCommand, messageCommand } from './commands'
+
+const program = new Command()
+
+program
+  .name('agent-telegram')
+  .description('CLI tool for Telegram communication via TDLib')
+  .version(pkg.version)
+
+program.addCommand(authCommand)
+program.addCommand(chatCommand)
+program.addCommand(messageCommand)
+
+await program.parseAsync(process.argv)
+
+export default program

package/src/platforms/telegram/client.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, mock, test } from 'bun:test'
+import { TelegramTdlibClient } from './client'
+import type { TelegramAccount, TelegramAccountPaths } from './types'
+
+const mockAccount: TelegramAccount = {
+  account_id: 'test',
+  api_id: 12345,
+  api_hash: 'abc',
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
+}
+
+const mockPaths: TelegramAccountPaths = {
+  account_dir: '/tmp/test-account',
+  database_dir: '/tmp/test-db',
+  files_dir: '/tmp/test-files',
+}
+
+describe('sendMessage confirmation', () => {
+  test('returns confirmed message id when updateMessageSendSucceeded arrives', async () => {
+    const tempId = 100
+    const serverId = 999
+    const events: any[] = []
+
+    const createClientId = mock(() => 1)
+    const send = mock((_clientId: number, request: any) => {
+      if (request['@type'] === 'getAuthorizationState') {
+        events.push({
+          '@type': 'updateAuthorizationState',
+          authorization_state: { '@type': 'authorizationStateReady' },
+          '@extra': request['@extra'],
+        })
+      }
+
+      if (request['@type'] === 'getChat') {
+        events.push({ '@type': 'chat', id: 42, title: 'test', unread_count: 0, '@extra': request['@extra'] })
+      }
+
+      if (request['@type'] === 'sendMessage') {
+        events.push({
+          '@type': 'message',
+          id: tempId,
+          chat_id: 42,
+          date: 1_710_000_000,
+          is_outgoing: true,
+          sender_id: { '@type': 'messageSenderUser', user_id: 1 },
+          content: {
+            '@type': 'messageText',
+            text: { '@type': 'formattedText', text: 'hello', entities: [] },
+          },
+          sending_state: { '@type': 'messageSendingStatePending' },
+          '@extra': request['@extra'],
+        })
+
+        events.push({
+          '@type': 'updateMessageSendSucceeded',
+          old_message_id: tempId,
+          message: {
+            '@type': 'message',
+            id: serverId,
+            chat_id: 42,
+            date: 1_710_000_001,
+            is_outgoing: true,
+            sender_id: { '@type': 'messageSenderUser', user_id: 1 },
+            content: {
+              '@type': 'messageText',
+              text: { '@type': 'formattedText', text: 'hello', entities: [] },
+            },
+          },
+        })
+      }
+    })
+
+    const receive = mock(() => events.shift() ?? null)
+    const client = new (TelegramTdlibClient as unknown as new (
+      account: TelegramAccount,
+      paths: TelegramAccountPaths,
+      tdjson: any,
+    ) => TelegramTdlibClient)(mockAccount, mockPaths, {
+      createClientId,
+      send,
+      receive,
+      libraryPath: '/mock/lib',
+    })
+
+    const result = await client.sendMessage('42', 'hello')
+
+    expect(result.id).toBe(serverId)
+  })
+})