agent-messenger 2.1.0 → 2.3.0

package/e2e/channeltalkbot.e2e.test.ts

@@ -13,13 +13,9 @@ let testGroupName = ''
 
 describe('ChannelBot E2E Tests', () => {
   beforeAll(async () => {
-    if (!CHANNELBOT_TEST_WORKSPACE_ID) {
-      console.warn(
-        'Skipping ChannelBot E2E: set E2E_CHANNELBOT_WORKSPACE_ID to run against a dedicated test workspace.',
-      )
-      return
-    }
     const group = await validateChannelBotEnvironment()
+    if (!group) return
+
     testGroupId = group.groupId
     testGroupName = group.groupName
     channelbotAvailable = true

package/e2e/config.ts

@@ -114,15 +114,14 @@ export const TEAMS_TEST_TEAM_NAME = process.env.E2E_TEAMS_TEAM_NAME || 'Agent Me
 export const TEAMS_TEST_CHANNEL_ID = process.env.E2E_TEAMS_CHANNEL_ID || ''
 export const TEAMS_TEST_CHANNEL = 'e2e-test'
 
-export async function validateTeamsEnvironment() {
-  const { runCLI, parseJSON } = await import('./helpers')
-
+export async function validateTeamsEnvironment(): Promise<boolean> {
   if (!TEAMS_TEST_TEAM_ID || !TEAMS_TEST_CHANNEL_ID) {
-    throw new Error(
-      'Teams E2E environment not configured. Set E2E_TEAMS_TEAM_ID and E2E_TEAMS_CHANNEL_ID environment variables.',
-    )
+    console.warn('Skipping Teams E2E: set E2E_TEAMS_TEAM_ID and E2E_TEAMS_CHANNEL_ID to run against a dedicated test team.')
+    return false
   }
 
+  const { runCLI, parseJSON } = await import('./helpers')
+
   const result = await runCLI('teams', ['auth', 'status'])
   if (result.exitCode !== 0) {
     throw new Error('Teams authentication failed. Please run: agent-teams auth extract')
@@ -144,6 +143,8 @@ export async function validateTeamsEnvironment() {
       )
     }
   }
+
+  return true
 }
 
 // ChannelBot Test Environment — requires E2E_CHANNELBOT_WORKSPACE_ID to opt-in.
@@ -153,9 +154,10 @@ export const CHANNELBOT_TEST_WORKSPACE_ID = process.env.E2E_CHANNELBOT_WORKSPACE
 export const CHANNELBOT_TEST_WORKSPACE_NAME = process.env.E2E_CHANNELBOT_WORKSPACE_NAME || ''
 export const E2E_GROUP_NAME = 'E2E'
 
-export async function validateChannelBotEnvironment(): Promise<{ groupId: string; groupName: string }> {
+export async function validateChannelBotEnvironment(): Promise<{ groupId: string; groupName: string } | null> {
   if (!CHANNELBOT_TEST_WORKSPACE_ID) {
-    throw new Error('ChannelBot E2E environment not configured. Set E2E_CHANNELBOT_WORKSPACE_ID.')
+    console.warn('Skipping ChannelBot E2E: set E2E_CHANNELBOT_WORKSPACE_ID to run against a dedicated test workspace.')
+    return null
   }
 
   const { runCLI, parseJSON } = await import('./helpers')
@@ -189,14 +191,174 @@ export async function validateChannelBotEnvironment(): Promise<{ groupId: string
   return { groupId: e2eGroup.id, groupName: e2eGroup.name }
 }
 
+// Webex Test Environment
+export const WEBEX_TEST_SPACE_ID = process.env.E2E_WEBEX_SPACE_ID || ''
+export const WEBEX_TEST_DM_EMAIL = process.env.E2E_WEBEX_DM_EMAIL || ''
+
+export async function validateWebexEnvironment(): Promise<boolean> {
+  if (!WEBEX_TEST_SPACE_ID) {
+    console.warn('Skipping Webex E2E: set E2E_WEBEX_SPACE_ID to run against a dedicated test space.')
+    return false
+  }
+
+  const { runCLI, parseJSON } = await import('./helpers')
+
+  const result = await runCLI('webex', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('Webex authentication failed. Run: agent-webex auth login or agent-webex auth extract')
+  }
+
+  const data = parseJSON<{ authenticated: boolean }>(result.stdout)
+  if (!data?.authenticated) {
+    throw new Error('Webex not authenticated. Run: agent-webex auth login or agent-webex auth extract')
+  }
+
+  return true
+}
+
+// Telegram Test Environment
+export const TELEGRAM_TEST_CHAT_ID = process.env.E2E_TELEGRAM_CHAT_ID || ''
+
+export async function validateTelegramEnvironment(): Promise<boolean> {
+  if (!TELEGRAM_TEST_CHAT_ID) {
+    console.warn('Skipping Telegram E2E: set E2E_TELEGRAM_CHAT_ID to run against a dedicated test chat.')
+    return false
+  }
+
+  const { runCLI } = await import('./helpers')
+
+  const result = await runCLI('telegram', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('Telegram authentication failed. Run: agent-telegram auth login')
+  }
+
+  return true
+}
+
+// WhatsApp Test Environment
+export const WHATSAPP_TEST_CHAT_ID = process.env.E2E_WHATSAPP_CHAT_ID || ''
+
+export async function validateWhatsAppEnvironment(): Promise<boolean> {
+  if (!WHATSAPP_TEST_CHAT_ID) {
+    console.warn('Skipping WhatsApp E2E: set E2E_WHATSAPP_CHAT_ID to run against a dedicated test chat.')
+    return false
+  }
+
+  const { runCLI, parseJSON } = await import('./helpers')
+
+  const result = await runCLI('whatsapp', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('WhatsApp authentication failed. Run: agent-whatsapp auth login')
+  }
+
+  const data = parseJSON<{ valid?: boolean }>(result.stdout)
+  if (data && 'valid' in data && !data.valid) {
+    throw new Error('WhatsApp credentials invalid. Run: agent-whatsapp auth login')
+  }
+
+  return true
+}
+
+// WhatsApp Bot Test Environment
+export const WHATSAPPBOT_TEST_PHONE_NUMBER = process.env.E2E_WHATSAPPBOT_PHONE_NUMBER || ''
+
+export async function validateWhatsAppBotEnvironment(): Promise<boolean> {
+  if (!WHATSAPPBOT_TEST_PHONE_NUMBER) {
+    console.warn('Skipping WhatsApp Bot E2E: set E2E_WHATSAPPBOT_PHONE_NUMBER to run against a dedicated test phone number.')
+    return false
+  }
+
+  const { runCLI, parseJSON } = await import('./helpers')
+
+  const result = await runCLI('whatsappbot', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error(
+      'WhatsApp Bot authentication failed. Run: agent-whatsappbot auth set <phone-number-id> <access-token>',
+    )
+  }
+
+  const data = parseJSON<{ valid: boolean }>(result.stdout)
+  if (!data?.valid) {
+    throw new Error(
+      'WhatsApp Bot credentials invalid or expired. Run: agent-whatsappbot auth set <phone-number-id> <access-token>',
+    )
+  }
+
+  return true
+}
+
+// LINE Test Environment
+export const LINE_TEST_CHAT_ID = process.env.E2E_LINE_CHAT_ID || ''
+
+export async function validateLineEnvironment(): Promise<boolean> {
+  if (!LINE_TEST_CHAT_ID) {
+    console.warn('Skipping LINE E2E: set E2E_LINE_CHAT_ID to run against a dedicated test chat.')
+    return false
+  }
+
+  const { runCLI } = await import('./helpers')
+
+  const result = await runCLI('line', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('LINE authentication failed. Run: agent-line auth login')
+  }
+
+  return true
+}
+
+// Instagram Test Environment
+export const INSTAGRAM_TEST_THREAD_ID = process.env.E2E_INSTAGRAM_THREAD_ID || ''
+export const INSTAGRAM_TEST_USERNAME = process.env.E2E_INSTAGRAM_USERNAME || ''
+
+export async function validateInstagramEnvironment(): Promise<boolean> {
+  if (!INSTAGRAM_TEST_THREAD_ID) {
+    console.warn('Skipping Instagram E2E: set E2E_INSTAGRAM_THREAD_ID to run against a dedicated test thread.')
+    return false
+  }
+
+  const { runCLI, parseJSON } = await import('./helpers')
+
+  const result = await runCLI('instagram', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('Instagram authentication failed. Run: agent-instagram auth login or agent-instagram auth extract')
+  }
+
+  const data = parseJSON<{ valid?: boolean }>(result.stdout)
+  if (data && 'valid' in data && !data.valid) {
+    throw new Error('Instagram credentials invalid. Run: agent-instagram auth login or agent-instagram auth extract')
+  }
+
+  return true
+}
+
+// KakaoTalk Test Environment
+export const KAKAOTALK_TEST_CHAT_ID = process.env.E2E_KAKAOTALK_CHAT_ID || ''
+
+export async function validateKakaoTalkEnvironment(): Promise<boolean> {
+  if (!KAKAOTALK_TEST_CHAT_ID) {
+    console.warn('Skipping KakaoTalk E2E: set E2E_KAKAOTALK_CHAT_ID to run against a dedicated test chat.')
+    return false
+  }
+
+  const { runCLI } = await import('./helpers')
+
+  const result = await runCLI('kakaotalk', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('KakaoTalk authentication failed. Run: agent-kakaotalk auth login or agent-kakaotalk auth extract')
+  }
+
+  return true
+}
+
 // Channel (user-auth) Test Environment — requires E2E_CHANNEL_WORKSPACE_ID to opt-in.
 // The E2E group is auto-discovered by name from the workspace's group list.
 export const CHANNEL_TEST_WORKSPACE_ID = process.env.E2E_CHANNEL_WORKSPACE_ID || ''
 export const CHANNEL_TEST_WORKSPACE_NAME = process.env.E2E_CHANNEL_WORKSPACE_NAME || ''
 
-export async function validateChannelEnvironment(): Promise<{ groupId: string; groupName: string }> {
+export async function validateChannelEnvironment(): Promise<{ groupId: string; groupName: string } | null> {
   if (!CHANNEL_TEST_WORKSPACE_ID) {
-    throw new Error('Channel E2E environment not configured. Set E2E_CHANNEL_WORKSPACE_ID.')
+    console.warn('Skipping Channel E2E: set E2E_CHANNEL_WORKSPACE_ID to run against a dedicated test workspace.')
+    return null
   }
 
   const { runCLI, parseJSON } = await import('./helpers')

package/e2e/helpers.ts

@@ -13,6 +13,13 @@ export async function runCLI(platform: string, args: string[]): Promise<CLIResul
     teams: 'agent-teams',
     channeltalkbot: 'agent-channeltalkbot',
     channeltalk: 'agent-channeltalk',
+    webex: 'agent-webex',
+    telegram: 'agent-telegram',
+    whatsapp: 'agent-whatsapp',
+    whatsappbot: 'agent-whatsappbot',
+    line: 'agent-line',
+    instagram: 'agent-instagram',
+    kakaotalk: 'agent-kakaotalk',
   }
   const command = commandMap[platform] || platform
 

package/e2e/instagram.e2e.test.ts

@@ -0,0 +1,97 @@
+import { afterEach, beforeAll, describe, expect, test } from 'bun:test'
+
+import { INSTAGRAM_TEST_THREAD_ID, INSTAGRAM_TEST_USERNAME, validateInstagramEnvironment } from './config'
+import { generateTestId, parseJSON, runCLI, waitForRateLimit } from './helpers'
+
+let instagramAvailable = false
+
+describe('Instagram E2E Tests', () => {
+  beforeAll(async () => {
+    instagramAvailable = await validateInstagramEnvironment()
+  })
+
+  afterEach(async () => {
+    await waitForRateLimit()
+  })
+
+  describe('auth', () => {
+    test('auth status returns exit code 0', async () => {
+      if (!instagramAvailable) return
+
+      const result = await runCLI('instagram', ['auth', 'status'])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('auth list returns accounts array', async () => {
+      if (!instagramAvailable) return
+
+      const result = await runCLI('instagram', ['auth', 'list'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown[]>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+  })
+
+  describe('chat', () => {
+    test('chat list returns chats', async () => {
+      if (!instagramAvailable) return
+
+      const result = await runCLI('instagram', ['chat', 'list', '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown[] | { chats: unknown[] }>(result.stdout)
+      expect(data).toBeDefined()
+    })
+
+    test('chat search returns results', async () => {
+      if (!instagramAvailable) return
+
+      const result = await runCLI('instagram', ['chat', 'search', 'test', '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+    })
+  })
+
+  describe('message', () => {
+    test('message send sends a message to thread', async () => {
+      if (!instagramAvailable) return
+
+      const testId = generateTestId()
+      const result = await runCLI('instagram', ['message', 'send', INSTAGRAM_TEST_THREAD_ID, `e2e ${testId}`])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('message list returns messages from thread', async () => {
+      if (!instagramAvailable) return
+
+      const result = await runCLI('instagram', ['message', 'list', INSTAGRAM_TEST_THREAD_ID, '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown[] | { messages: unknown[] }>(result.stdout)
+      expect(data).toBeDefined()
+    })
+
+    test('message send-to sends a message to username', async () => {
+      if (!instagramAvailable) return
+      if (!INSTAGRAM_TEST_USERNAME) return
+
+      const testId = generateTestId()
+      const result = await runCLI('instagram', ['message', 'send-to', INSTAGRAM_TEST_USERNAME, `e2e ${testId}`])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('message search returns results', async () => {
+      if (!instagramAvailable) return
+
+      const result = await runCLI('instagram', ['message', 'search', 'test', '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('message search-users returns results', async () => {
+      if (!instagramAvailable) return
+
+      const result = await runCLI('instagram', ['message', 'search-users', 'test'])
+      expect(result.exitCode).toBe(0)
+    })
+  })
+})

package/e2e/kakaotalk.e2e.test.ts

@@ -0,0 +1,74 @@
+import { afterEach, beforeAll, describe, expect, test } from 'bun:test'
+
+import { KAKAOTALK_TEST_CHAT_ID, validateKakaoTalkEnvironment } from './config'
+import { generateTestId, parseJSON, runCLI, waitForRateLimit } from './helpers'
+
+let kakaotalkAvailable = false
+
+describe('KakaoTalk E2E Tests', () => {
+  beforeAll(async () => {
+    kakaotalkAvailable = await validateKakaoTalkEnvironment()
+  })
+
+  afterEach(async () => {
+    await waitForRateLimit()
+  })
+
+  describe('auth', () => {
+    test('auth status returns valid auth info', async () => {
+      if (!kakaotalkAvailable) return
+
+      const result = await runCLI('kakaotalk', ['auth', 'status'])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('auth list returns accounts array', async () => {
+      if (!kakaotalkAvailable) return
+
+      const result = await runCLI('kakaotalk', ['auth', 'list'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown[]>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+  })
+
+  describe('chat', () => {
+    test('chat list returns chats', async () => {
+      if (!kakaotalkAvailable) return
+
+      const result = await runCLI('kakaotalk', ['chat', 'list'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown>(result.stdout)
+      expect(data).toBeDefined()
+    })
+
+    test('chat list with search filter returns chats', async () => {
+      if (!kakaotalkAvailable) return
+
+      const result = await runCLI('kakaotalk', ['chat', 'list', '--search', 'test'])
+      expect(result.exitCode).toBe(0)
+    })
+  })
+
+  describe('message', () => {
+    test('message send sends a message to the test chat', async () => {
+      if (!kakaotalkAvailable) return
+
+      const testId = generateTestId()
+      const result = await runCLI('kakaotalk', ['message', 'send', KAKAOTALK_TEST_CHAT_ID, `e2e ${testId}`])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('message list returns messages from the test chat', async () => {
+      if (!kakaotalkAvailable) return
+
+      const result = await runCLI('kakaotalk', ['message', 'list', KAKAOTALK_TEST_CHAT_ID, '-n', '5'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown>(result.stdout)
+      expect(data).toBeDefined()
+    })
+  })
+})

package/e2e/line.e2e.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, beforeAll, describe, expect, test } from 'bun:test'
+
+import { LINE_TEST_CHAT_ID, validateLineEnvironment } from './config'
+import { generateTestId, parseJSON, runCLI, waitForRateLimit } from './helpers'
+
+let lineAvailable = false
+
+describe('LINE E2E Tests', () => {
+  beforeAll(async () => {
+    lineAvailable = await validateLineEnvironment()
+  })
+
+  afterEach(async () => {
+    await waitForRateLimit()
+  })
+
+  describe('auth', () => {
+    test('auth status returns valid auth info', async () => {
+      if (!lineAvailable) return
+
+      const result = await runCLI('line', ['auth', 'status'])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('auth list returns accounts array', async () => {
+      if (!lineAvailable) return
+
+      const result = await runCLI('line', ['auth', 'list'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown[]>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+  })
+
+  describe('chat', () => {
+    test('chat list returns chats', async () => {
+      if (!lineAvailable) return
+
+      const result = await runCLI('line', ['chat', 'list', '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown>(result.stdout)
+      expect(data).toBeDefined()
+    })
+  })
+
+  describe('friend', () => {
+    test('friend list returns friends', async () => {
+      if (!lineAvailable) return
+
+      const result = await runCLI('line', ['friend', 'list'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown>(result.stdout)
+      expect(data).toBeDefined()
+    })
+  })
+
+  describe('message', () => {
+    test('message send sends a message to the test chat', async () => {
+      if (!lineAvailable) return
+
+      const testId = generateTestId()
+      const result = await runCLI('line', ['message', 'send', LINE_TEST_CHAT_ID, `e2e ${testId}`])
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('message list returns messages from the test chat', async () => {
+      if (!lineAvailable) return
+
+      const result = await runCLI('line', ['message', 'list', LINE_TEST_CHAT_ID, '-n', '5'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<unknown>(result.stdout)
+      expect(data).toBeDefined()
+    })
+  })
+
+  describe('profile', () => {
+    test('profile returns current user profile', async () => {
+      if (!lineAvailable) return
+
+      const result = await runCLI('line', ['profile'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<Record<string, unknown>>(result.stdout)
+      expect(data).toBeDefined()
+      expect(typeof data).toBe('object')
+    })
+  })
+})