agent-messenger 1.14.0 → 2.0.0

package/src/platforms/instagram/listener.test.ts

@@ -0,0 +1,130 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { InstagramListener } from '@/platforms/instagram/listener'
+import type { InstagramChatSummary } from '@/platforms/instagram/types'
+
+function makeMockClient(chats: InstagramChatSummary[] = []) {
+  return {
+    listChats: spyOn({ listChats: async () => chats }, 'listChats'),
+    getUserId: () => '123',
+  } as any
+}
+
+function makeChat(overrides: Partial<InstagramChatSummary> = {}): InstagramChatSummary {
+  return {
+    id: 'thread-1',
+    name: 'Test',
+    type: 'private',
+    is_group: false,
+    participant_count: 2,
+    unread_count: 0,
+    last_message: {
+      id: 'msg-1',
+      thread_id: 'thread-1',
+      from: '456',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      is_outgoing: false,
+      type: 'text',
+      text: 'hello',
+    },
+    ...overrides,
+  }
+}
+
+describe('InstagramListener', () => {
+  let listener: InstagramListener
+
+  afterEach(() => {
+    listener?.stop()
+  })
+
+  test('emits connected on start', async () => {
+    const client = makeMockClient([makeChat()])
+    listener = new InstagramListener(client, { pollInterval: 60_000 })
+
+    const connected = new Promise<{ userId: string }>((resolve) => {
+      listener.on('connected', resolve)
+    })
+
+    await listener.start()
+    const result = await connected
+    expect(result.userId).toBe('123')
+  })
+
+  test('stop emits disconnected', async () => {
+    const client = makeMockClient([])
+    listener = new InstagramListener(client, { pollInterval: 60_000 })
+
+    const disconnected = new Promise<void>((resolve) => {
+      listener.on('disconnected', resolve)
+    })
+
+    await listener.start()
+    listener.stop()
+    await disconnected
+  })
+
+  test('does not emit message for initial poll', async () => {
+    const client = makeMockClient([makeChat()])
+    listener = new InstagramListener(client, { pollInterval: 60_000 })
+
+    const messages: unknown[] = []
+    listener.on('message', (msg) => messages.push(msg))
+
+    await listener.start()
+    await new Promise((r) => setTimeout(r, 50))
+
+    expect(messages).toHaveLength(0)
+  })
+
+  test('multiple start calls are idempotent', async () => {
+    const client = makeMockClient([])
+    listener = new InstagramListener(client, { pollInterval: 60_000 })
+
+    await listener.start()
+    await listener.start()
+
+    expect(client.listChats).toHaveBeenCalledTimes(1)
+  })
+
+  test('emits error when listChats throws', async () => {
+    const client = makeMockClient()
+    client.listChats.mockRejectedValueOnce(new Error('network error'))
+    listener = new InstagramListener(client, { pollInterval: 60_000 })
+
+    const errorPromise = new Promise<Error>((resolve) => {
+      listener.on('error', resolve)
+    })
+
+    await listener.start()
+    const err = await errorPromise
+    expect(err.message).toBe('network error')
+  })
+
+  test('on/off registers and unregisters handlers', () => {
+    const client = makeMockClient()
+    listener = new InstagramListener(client, { pollInterval: 60_000 })
+
+    let called = false
+    const handler = () => { called = true }
+    listener.on('disconnected', handler)
+    listener.off('disconnected', handler)
+    listener.stop()
+
+    expect(called).toBe(false)
+  })
+
+  test('once fires handler only once', async () => {
+    const client = makeMockClient([])
+    listener = new InstagramListener(client, { pollInterval: 60_000 })
+
+    let count = 0
+    listener.once('connected', () => { count++ })
+
+    await listener.start()
+    listener.stop()
+    await listener.start()
+
+    expect(count).toBe(1)
+  })
+})

package/src/platforms/instagram/listener.ts

@@ -0,0 +1,106 @@
+import { EventEmitter } from 'events'
+
+import type { InstagramClient } from './client'
+import type { InstagramMessageSummary } from './types'
+
+export interface InstagramListenerEventMap {
+  message: [InstagramMessageSummary]
+  error: [Error]
+  connected: [{ userId: string }]
+  disconnected: []
+}
+
+type EventKey = keyof InstagramListenerEventMap
+
+const DEFAULT_POLL_INTERVAL = 5_000
+
+export class InstagramListener {
+  private client: InstagramClient
+  private running = false
+  private emitter = new EventEmitter()
+  private pollInterval: number
+  private pollTimer: ReturnType<typeof setTimeout> | null = null
+  private seenMessageIds = new Set<string>()
+  private initialized = false
+
+  constructor(client: InstagramClient, options?: { pollInterval?: number }) {
+    this.client = client
+    this.pollInterval = options?.pollInterval ?? DEFAULT_POLL_INTERVAL
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+    this.initialized = false
+    this.seenMessageIds.clear()
+
+    try {
+      const chats = await this.client.listChats(20)
+      for (const chat of chats) {
+        if (chat.last_message?.id) {
+          this.seenMessageIds.add(chat.last_message.id)
+        }
+      }
+      this.initialized = true
+      this.emitter.emit('connected', { userId: this.client.getUserId() ?? '' })
+      this.schedulePoll()
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      if (this.running) this.schedulePoll()
+    }
+  }
+
+  stop(): void {
+    this.running = false
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer)
+      this.pollTimer = null
+    }
+    this.emitter.emit('disconnected')
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: InstagramListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: unknown[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: InstagramListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: unknown[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: InstagramListenerEventMap[K]) => void): this {
+    this.emitter.once(event, listener as (...args: unknown[]) => void)
+    return this
+  }
+
+  private schedulePoll(): void {
+    if (!this.running) return
+    this.pollTimer = setTimeout(() => this.poll(), this.pollInterval)
+  }
+
+  private async poll(): Promise<void> {
+    if (!this.running) return
+
+    try {
+      const chats = await this.client.listChats(20)
+
+      for (const chat of chats) {
+        if (!chat.last_message) continue
+        const msgId = chat.last_message.id
+        if (!msgId || this.seenMessageIds.has(msgId)) continue
+
+        this.seenMessageIds.add(msgId)
+        if (this.initialized) {
+          this.emitter.emit('message', chat.last_message)
+        }
+      }
+
+      this.initialized = true
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+    }
+
+    this.schedulePoll()
+  }
+}

package/src/platforms/instagram/types.test.ts

@@ -0,0 +1,228 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  InstagramError,
+  createAccountId,
+  extractMessageText,
+  getMessageType,
+} from './types'
+
+describe('createAccountId', () => {
+  it('normalizes plain username', () => {
+    expect(createAccountId('username')).toBe('username')
+  })
+
+  it('strips leading @', () => {
+    expect(createAccountId('@username')).toBe('username')
+  })
+
+  it('replaces dots with hyphens', () => {
+    expect(createAccountId('user.name')).toBe('user-name')
+  })
+
+  it('replaces underscores with hyphens', () => {
+    expect(createAccountId('user_name_123')).toBe('user-name-123')
+  })
+
+  it('replaces spaces with hyphens', () => {
+    expect(createAccountId('user name')).toBe('user-name')
+  })
+
+  it('collapses multiple separators into one hyphen', () => {
+    expect(createAccountId('user..name__123')).toBe('user-name-123')
+  })
+
+  it('lowercases the result', () => {
+    expect(createAccountId('UserName')).toBe('username')
+  })
+
+  it('trims leading and trailing whitespace', () => {
+    expect(createAccountId('  username  ')).toBe('username')
+  })
+
+  it('handles @ with dots and underscores', () => {
+    expect(createAccountId('@user.name_123')).toBe('user-name-123')
+  })
+
+  it('returns default for empty string', () => {
+    expect(createAccountId('')).toBe('default')
+  })
+
+  it('returns default for whitespace-only string', () => {
+    expect(createAccountId('   ')).toBe('default')
+  })
+
+  it('returns default for @ only', () => {
+    expect(createAccountId('@')).toBe('default')
+  })
+})
+
+describe('getMessageType', () => {
+  it('returns text for text item_type', () => {
+    expect(getMessageType({ item_type: 'text' })).toBe('text')
+  })
+
+  it('returns media_share for media_share item_type', () => {
+    expect(getMessageType({ item_type: 'media_share' })).toBe('media_share')
+  })
+
+  it('returns reel_share for reel_share item_type', () => {
+    expect(getMessageType({ item_type: 'reel_share' })).toBe('reel_share')
+  })
+
+  it('returns reel_share for clip item_type', () => {
+    expect(getMessageType({ item_type: 'clip' })).toBe('reel_share')
+  })
+
+  it('returns reel_share for felix_share item_type', () => {
+    expect(getMessageType({ item_type: 'felix_share' })).toBe('reel_share')
+  })
+
+  it('returns link for link item_type', () => {
+    expect(getMessageType({ item_type: 'link' })).toBe('link')
+  })
+
+  it('returns like for like item_type', () => {
+    expect(getMessageType({ item_type: 'like' })).toBe('like')
+  })
+
+  it('returns voice_media for voice_media item_type', () => {
+    expect(getMessageType({ item_type: 'voice_media' })).toBe('voice_media')
+  })
+
+  it('returns animated_media for animated_media item_type', () => {
+    expect(getMessageType({ item_type: 'animated_media' })).toBe('animated_media')
+  })
+
+  it('returns story_share for story_share item_type', () => {
+    expect(getMessageType({ item_type: 'story_share' })).toBe('story_share')
+  })
+
+  it('returns action_log for action_log item_type', () => {
+    expect(getMessageType({ item_type: 'action_log' })).toBe('action_log')
+  })
+
+  it('returns placeholder for placeholder item_type', () => {
+    expect(getMessageType({ item_type: 'placeholder' })).toBe('placeholder')
+  })
+
+  it('passes through unknown item types as-is', () => {
+    expect(getMessageType({ item_type: 'some_future_type' })).toBe('some_future_type')
+  })
+
+  it('returns unknown when item_type is missing', () => {
+    expect(getMessageType({})).toBe('unknown')
+  })
+
+  it('returns unknown when item_type is not a string', () => {
+    expect(getMessageType({ item_type: 42 })).toBe('unknown')
+    expect(getMessageType({ item_type: null })).toBe('unknown')
+  })
+})
+
+describe('extractMessageText', () => {
+  it('extracts text from text items', () => {
+    expect(extractMessageText({ item_type: 'text', text: 'hello' })).toBe('hello')
+  })
+
+  it('returns undefined for text item without text field', () => {
+    expect(extractMessageText({ item_type: 'text' })).toBeUndefined()
+  })
+
+  it('extracts caption from media_share items', () => {
+    const item = {
+      item_type: 'media_share',
+      media_share: { caption: { text: 'nice photo' } },
+    }
+    expect(extractMessageText(item)).toBe('nice photo')
+  })
+
+  it('returns undefined for media_share without caption', () => {
+    expect(extractMessageText({ item_type: 'media_share', media_share: {} })).toBeUndefined()
+  })
+
+  it('returns undefined for media_share without media_share field', () => {
+    expect(extractMessageText({ item_type: 'media_share' })).toBeUndefined()
+  })
+
+  it('extracts text from reel_share items', () => {
+    const item = { item_type: 'reel_share', reel_share: { text: 'cool reel' } }
+    expect(extractMessageText(item)).toBe('cool reel')
+  })
+
+  it('returns fallback for reel_share without text', () => {
+    expect(extractMessageText({ item_type: 'reel_share', reel_share: {} })).toBe('Shared a reel')
+  })
+
+  it('returns fallback for reel_share without reel_share field', () => {
+    expect(extractMessageText({ item_type: 'reel_share' })).toBe('Shared a reel')
+  })
+
+  it('extracts text from link items', () => {
+    const item = { item_type: 'link', link: { text: 'check this out' } }
+    expect(extractMessageText(item)).toBe('check this out')
+  })
+
+  it('returns undefined for link without text', () => {
+    expect(extractMessageText({ item_type: 'link', link: {} })).toBeUndefined()
+  })
+
+  it('returns heart emoji for like items', () => {
+    expect(extractMessageText({ item_type: 'like' })).toBe('❤️')
+  })
+
+  it('extracts description from action_log items', () => {
+    const item = {
+      item_type: 'action_log',
+      action_log: { description: 'liked a message' },
+    }
+    expect(extractMessageText(item)).toBe('liked a message')
+  })
+
+  it('returns undefined for action_log without description', () => {
+    expect(extractMessageText({ item_type: 'action_log', action_log: {} })).toBeUndefined()
+  })
+
+  it('returns undefined for voice_media', () => {
+    expect(extractMessageText({ item_type: 'voice_media' })).toBeUndefined()
+  })
+
+  it('returns undefined for animated_media', () => {
+    expect(extractMessageText({ item_type: 'animated_media' })).toBeUndefined()
+  })
+
+  it('returns undefined for unknown item type', () => {
+    expect(extractMessageText({ item_type: 'unknown_type' })).toBeUndefined()
+  })
+})
+
+describe('InstagramError', () => {
+  it('sets name to InstagramError', () => {
+    const error = new InstagramError('something went wrong')
+    expect(error.name).toBe('InstagramError')
+  })
+
+  it('sets the message', () => {
+    const error = new InstagramError('rate limited')
+    expect(error.message).toBe('rate limited')
+  })
+
+  it('uses default code when not provided', () => {
+    const error = new InstagramError('oops')
+    expect(error.code).toBe('instagram_error')
+  })
+
+  it('accepts a string code', () => {
+    const error = new InstagramError('not found', 'not_found')
+    expect(error.code).toBe('not_found')
+  })
+
+  it('accepts a numeric code', () => {
+    const error = new InstagramError('server error', 500)
+    expect(error.code).toBe(500)
+  })
+
+  it('is an instance of Error', () => {
+    const error = new InstagramError('test')
+    expect(error).toBeInstanceOf(Error)
+  })
+})

package/src/platforms/instagram/types.ts

@@ -0,0 +1,153 @@
+export interface InstagramAccount {
+  account_id: string
+  username: string
+  full_name?: string
+  profile_pic_url?: string
+  pk?: string
+  created_at: string
+  updated_at: string
+}
+
+export interface InstagramConfig {
+  current: string | null
+  accounts: Record<string, InstagramAccount>
+}
+
+export interface InstagramAccountPaths {
+  account_dir: string
+  session_path: string
+}
+
+export class InstagramError extends Error {
+  code: string | number
+
+  constructor(message: string, code: string | number = 'instagram_error') {
+    super(message)
+    this.name = 'InstagramError'
+    this.code = code
+  }
+}
+
+export function createAccountId(input: string): string {
+  const normalized = input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+
+  return normalized || 'default'
+}
+
+export interface InstagramChatSummary {
+  id: string
+  name: string
+  type: 'private' | 'group'
+  is_group: boolean
+  participant_count: number
+  unread_count: number
+  last_message?: InstagramMessageSummary
+}
+
+export interface InstagramMessageSummary {
+  id: string
+  thread_id: string
+  from: string
+  from_name?: string
+  timestamp: string
+  is_outgoing: boolean
+  type: string
+  text?: string
+  media_url?: string
+}
+
+export interface InstagramSessionState {
+  cookies: string
+  device: {
+    phone_id: string
+    uuid: string
+    android_device_id: string
+    advertising_id: string
+    client_session_id: string
+    device_string: string
+  }
+  authorization?: string
+  user_id?: string
+  mid?: string
+  challenge_path?: string
+}
+
+export function getMessageType(item: Record<string, unknown>): string {
+  const itemType = item['item_type']
+  if (typeof itemType !== 'string') return 'unknown'
+
+  switch (itemType) {
+    case 'clip':
+    case 'felix_share':
+    case 'reel_share': return 'reel_share'
+    default: return itemType
+  }
+}
+
+export function extractMessageText(item: Record<string, unknown>): string | undefined {
+  const itemType = item['item_type'] as string | undefined
+
+  if (item['text'] != null) return item['text'] as string
+
+  const link = item['link'] as Record<string, unknown> | undefined
+  if (link?.['text'] != null) return link['text'] as string
+
+  const reelShare = item['reel_share'] as Record<string, unknown> | undefined
+  if (reelShare?.['text'] != null) return reelShare['text'] as string
+  if (itemType === 'reel_share') return 'Shared a reel'
+
+  const storyShare = item['story_share'] as Record<string, unknown> | undefined
+  if (storyShare?.['message'] != null) return storyShare['message'] as string
+
+  const clip = item['clip'] as Record<string, unknown> | undefined
+  const clipInner = clip?.['clip'] as Record<string, unknown> | undefined
+  const clipCaption = clipInner?.['caption'] as Record<string, unknown> | undefined
+  if (clipCaption?.['text'] != null) return clipCaption['text'] as string
+
+  const mediaShare = item['media_share'] as Record<string, unknown> | undefined
+  const mediaCaption = mediaShare?.['caption'] as Record<string, unknown> | undefined
+  if (mediaCaption?.['text'] != null) return mediaCaption['text'] as string
+
+  if (itemType === 'like') return '❤️'
+
+  const actionLog = item['action_log'] as Record<string, unknown> | undefined
+  if (actionLog?.['description'] != null) return actionLog['description'] as string
+
+  return undefined
+}
+
+function findImageUrl(candidates: unknown): string | undefined {
+  if (!Array.isArray(candidates) || candidates.length === 0) return undefined
+  const best = candidates[0] as Record<string, unknown> | undefined
+  return (best?.['url'] as string) ?? undefined
+}
+
+export function extractMediaUrl(item: Record<string, unknown>): string | undefined {
+  const media = item['media'] as Record<string, unknown> | undefined
+  if (media) {
+    const images = media['image_versions2'] as Record<string, unknown> | undefined
+    const url = findImageUrl(images?.['candidates'])
+    if (url) return url
+    const videoVersions = media['video_versions'] as unknown[] | undefined
+    if (videoVersions?.[0]) return ((videoVersions[0] as Record<string, unknown>)['url'] as string) ?? undefined
+  }
+
+  const mediaShare = item['media_share'] as Record<string, unknown> | undefined
+  if (mediaShare) {
+    const images = mediaShare['image_versions2'] as Record<string, unknown> | undefined
+    return findImageUrl(images?.['candidates'])
+  }
+
+  const visualMedia = item['visual_media'] as Record<string, unknown> | undefined
+  if (visualMedia) {
+    const innerMedia = visualMedia['media'] as Record<string, unknown> | undefined
+    const images = innerMedia?.['image_versions2'] as Record<string, unknown> | undefined
+    return findImageUrl(images?.['candidates'])
+  }
+
+  return undefined
+}