agent-messenger 1.14.0 → 2.0.0

package/src/platforms/discordbot/client.ts

@@ -14,20 +14,41 @@ interface RateLimitBucket {
 }
 
 export class DiscordBotClient {
-  private token: string
+  private token: string | null = null
   private buckets: Map<string, RateLimitBucket> = new Map()
   private globalRateLimitUntil: number = 0
 
-  constructor(token: string) {
-    if (!token) {
-      throw new DiscordBotError('Token is required', 'missing_token')
+  async login(credentials?: { token: string }): Promise<this> {
+    if (credentials) {
+      if (!credentials.token) {
+        throw new DiscordBotError('Token is required', 'missing_token')
+      }
+      this.token = credentials.token
+      return this
+    }
+
+    const { DiscordBotCredentialManager } = await import('./credential-manager')
+    const credManager = new DiscordBotCredentialManager()
+    const creds = await credManager.getCredentials()
+    if (!creds?.token) {
+      throw new DiscordBotError(
+        'No Discord bot credentials found. Run "auth set <token>" first.',
+        'no_credentials',
+      )
+    }
+    return this.login({ token: creds.token })
+  }
+
+  private ensureAuth(): string {
+    if (!this.token) {
+      throw new DiscordBotError('Not authenticated. Call .login() first.', 'not_authenticated')
     }
-    this.token = token
+    return this.token
   }
 
   private getHeaders(): Record<string, string> {
     return {
-      Authorization: `Bot ${this.token}`,
+      Authorization: `Bot ${this.ensureAuth()}`,
       'User-Agent': 'DiscordBot (https://github.com/devxoul/agent-messenger, 1.0)',
       'Content-Type': 'application/json',
     }
@@ -164,7 +185,7 @@ export class DiscordBotClient {
       await this.waitForRateLimit(bucketKey)
 
       const headers: Record<string, string> = {
-        Authorization: `Bot ${this.token}`,
+        Authorization: `Bot ${this.ensureAuth()}`,
         'User-Agent': 'DiscordBot (https://github.com/devxoul/agent-messenger, 1.0)',
       }
 

package/src/platforms/discordbot/commands/auth.test.ts

@@ -21,11 +21,7 @@ const mockListGuilds = mock(() =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    constructor(token: string) {
-      if (!token) {
-        throw new Error('Token is required')
-      }
-    }
+    async login(_credentials?: any) { return this }
     testAuth = mockTestAuth
     listGuilds = mockListGuilds
   },

package/src/platforms/discordbot/commands/auth.ts

@@ -28,7 +28,7 @@ interface ActionResult {
 
 export async function setAction(token: string, options: ActionOptions): Promise<ActionResult> {
   try {
-    const client = new DiscordBotClient(token)
+    const client = await new DiscordBotClient().login({ token })
     const authInfo = await client.testAuth()
 
     if (!authInfo.bot) {
@@ -90,7 +90,7 @@ export async function statusAction(options: ActionOptions): Promise<ActionResult
     let authInfo: { id: string; username: string; bot?: boolean } | null = null
 
     try {
-      const client = new DiscordBotClient(creds.token)
+      const client = await new DiscordBotClient().login({ token: creds.token })
       authInfo = await client.testAuth()
       valid = authInfo.bot === true
     } catch {

package/src/platforms/discordbot/commands/channel.test.ts

@@ -31,11 +31,7 @@ const mockResolveChannel = mock((_guildId: string, channel: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    constructor(token: string) {
-      if (!token) {
-        throw new Error('Token is required')
-      }
-    }
+    async login(_credentials?: any) { return this }
     listChannels = mockListChannels
     getChannel = mockGetChannel
     resolveChannel = mockResolveChannel

package/src/platforms/discordbot/commands/message.test.ts

@@ -68,9 +68,7 @@ const mockResolveChannel = mock((_guildId: string, channel: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    constructor(token: string) {
-      if (!token) throw new Error('Token is required')
-    }
+    async login(_credentials?: any) { return this }
     sendMessage = mockSendMessage
     getMessages = mockGetMessages
     getMessage = mockGetMessage

package/src/platforms/discordbot/commands/server.test.ts

@@ -22,11 +22,7 @@ const mockGetGuild = mock((guildId: string) =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    constructor(token: string) {
-      if (!token) {
-        throw new Error('Token is required')
-      }
-    }
+    async login(_credentials?: any) { return this }
     listGuilds = mockListGuilds
     getGuild = mockGetGuild
   },

package/src/platforms/discordbot/commands/shared.ts

@@ -19,7 +19,7 @@ export async function getClient(options: BotOption): Promise<DiscordBotClient> {
     process.exit(1)
   }
 
-  return new DiscordBotClient(creds.token)
+  return new DiscordBotClient().login({ token: creds.token })
 }
 
 export async function getCurrentServer(options: BotOption): Promise<string> {

package/src/platforms/discordbot/commands/snapshot.test.ts

@@ -41,9 +41,7 @@ const mockListUsers = mock((_guildId: string) =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    constructor(token: string) {
-      if (!token) throw new Error('Token is required')
-    }
+    async login(_credentials?: any) { return this }
     listChannels = mockListChannels
     getMessages = mockGetMessages
     listUsers = mockListUsers

package/src/platforms/discordbot/commands/thread.test.ts

@@ -29,9 +29,7 @@ const mockResolveChannel = mock((_guildId: string, channel: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    constructor(token: string) {
-      if (!token) throw new Error('Token is required')
-    }
+    async login(_credentials?: any) { return this }
     createThread = mockCreateThread
     archiveThread = mockArchiveThread
     resolveChannel = mockResolveChannel

package/src/platforms/discordbot/commands/user.test.ts

@@ -28,11 +28,7 @@ const mockGetUser = mock((userId: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    constructor(token: string) {
-      if (!token) {
-        throw new Error('Token is required')
-      }
-    }
+    async login(_credentials?: any) { return this }
     listUsers = mockListUsers
     getUser = mockGetUser
   },

package/src/platforms/instagram/cli.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env bun
+
+import type { Command as CommandType } from 'commander'
+import { Command } from 'commander'
+
+import pkg from '../../../package.json' with { type: 'json' }
+import { authCommand, chatCommand, messageCommand } from './commands/index'
+import { ensureInstagramAuth } from './ensure-auth'
+
+function isAuthCommand(command: CommandType): boolean {
+  let cmd: CommandType | null = command
+  while (cmd) {
+    if (cmd.name() === 'auth') return true
+    cmd = cmd.parent
+  }
+  return false
+}
+
+const program = new Command()
+
+program
+  .name('agent-instagram')
+  .description('CLI tool for Instagram DMs via private mobile API')
+  .version(pkg.version)
+
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+  if (isAuthCommand(actionCommand)) return
+  await ensureInstagramAuth()
+})
+
+program.addCommand(authCommand)
+program.addCommand(chatCommand)
+program.addCommand(messageCommand)
+
+program.parse(process.argv)
+
+export default program

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

@@ -0,0 +1,396 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test'
+import { generateKeyPairSync } from 'node:crypto'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { InstagramClient } from '@/platforms/instagram/client'
+import { InstagramError, type InstagramSessionState } from '@/platforms/instagram/types'
+
+const testDir = join(import.meta.dir, `.test-client-${Date.now()}`)
+const sessionPath = join(testDir, 'session.json')
+
+const SESSION: InstagramSessionState = {
+  cookies: 'sessionid=abc123; ds_user_id=42',
+  user_id: '42',
+  device: {
+    phone_id: '00000000-0000-0000-0000-000000000001',
+    uuid: '00000000-0000-0000-0000-000000000002',
+    android_device_id: 'android-deadbeef',
+    advertising_id: '00000000-0000-0000-0000-000000000003',
+    client_session_id: '00000000-0000-0000-0000-000000000004',
+    device_string: '13.0/33; 480dpi; 1080x2340; samsung; SM-S911B; SM-S911B; qcom; en_US; 556927984',
+  },
+}
+
+let rsaPublicKeyBase64: string
+
+beforeAll(() => {
+  mkdirSync(testDir, { recursive: true })
+  writeFileSync(sessionPath, JSON.stringify(SESSION))
+
+  const { publicKey } = generateKeyPairSync('rsa', { modulusLength: 1024 })
+  const pem = publicKey.export({ type: 'pkcs1', format: 'pem' }) as string
+  rsaPublicKeyBase64 = Buffer.from(pem).toString('base64')
+})
+
+afterAll(() => {
+  rmSync(testDir, { recursive: true, force: true })
+})
+
+const originalFetch = globalThis.fetch
+let fetchResponses: Response[] = []
+let fetchCalls: Array<{ url: string; init?: RequestInit }> = []
+let fetchIndex = 0
+
+beforeEach(() => {
+  fetchCalls = []
+  fetchResponses = []
+  fetchIndex = 0
+  ;(globalThis as Record<string, unknown>).fetch = async (
+    url: string | URL | Request,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    fetchCalls.push({ url: String(url), init })
+    const res = fetchResponses[fetchIndex++]
+    if (!res) throw new Error('No mock response queued')
+    return res
+  }
+})
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+})
+
+function jsonResponse(body: unknown, status = 200, headers: Record<string, string> = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json', ...headers },
+  })
+}
+
+function urlParamsBody(callIndex = 0): Record<string, string> {
+  const raw = fetchCalls[callIndex]?.init?.body
+  if (!raw || typeof raw !== 'string') return {}
+  return Object.fromEntries(new URLSearchParams(raw))
+}
+
+async function loadedClient(): Promise<InstagramClient> {
+  const client = new InstagramClient()
+  await client.loadSession(sessionPath)
+  return client
+}
+
+describe('InstagramClient', () => {
+  describe('constructor', () => {
+    test('creates instance with default credential manager', () => {
+      const client = new InstagramClient()
+      expect(client).toBeInstanceOf(InstagramClient)
+    })
+  })
+
+  describe('login', () => {
+    test('throws when no account configured', async () => {
+      const mockManager = {
+        getAccount: () => Promise.resolve(null),
+      } as any
+
+      const client = new InstagramClient(mockManager)
+
+      await expect(client.login()).rejects.toThrow(InstagramError)
+      await expect(client.login()).rejects.toThrow('No Instagram credentials found')
+    })
+
+    test('loads session from disk when file exists', async () => {
+      const mockManager = {
+        getAccount: () =>
+          Promise.resolve({ account_id: 'testuser', username: 'testuser', created_at: '', updated_at: '' }),
+        ensureAccountPaths: () =>
+          Promise.resolve({ account_dir: testDir, session_path: sessionPath }),
+      } as any
+
+      const client = new InstagramClient(mockManager)
+
+      await client.login()
+
+      expect(client.getUserId()).toBe('42')
+    })
+  })
+
+  describe('plaintextPassword format', () => {
+    test('produces #PWD_INSTAGRAM:0:timestamp:rawpassword format', async () => {
+      fetchResponses.push(
+        new Response(null, {
+          status: 200,
+          headers: {},
+        }),
+      )
+      fetchResponses.push(
+        jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }),
+      )
+
+      const client = new InstagramClient()
+      const before = Math.floor(Date.now() / 1000)
+      await client.authenticate('user', 'mypassword')
+      const after = Math.floor(Date.now() / 1000)
+
+      const loginBody = urlParamsBody(1)
+      const encPassword = loginBody['enc_password'] ?? ''
+
+      expect(encPassword).toMatch(/^#PWD_INSTAGRAM:0:\d+:/)
+      const [, , ts, raw] = encPassword.split(':')
+      expect(Number(ts)).toBeGreaterThanOrEqual(before)
+      expect(Number(ts)).toBeLessThanOrEqual(after)
+      expect(raw).toBe('mypassword')
+    })
+  })
+
+  describe('encryptPassword format', () => {
+    test('produces #PWD_INSTAGRAM:4:timestamp:base64 format when encryption key provided', async () => {
+      fetchResponses.push(
+        new Response(null, {
+          status: 200,
+          headers: new Headers({
+            'ig-set-password-encryption-pub-key': rsaPublicKeyBase64,
+            'ig-set-password-encryption-key-id': '7',
+          }),
+        }),
+      )
+      fetchResponses.push(
+        jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }),
+      )
+
+      const client = new InstagramClient()
+      const before = Math.floor(Date.now() / 1000)
+      await client.authenticate('user', 'secret')
+      const after = Math.floor(Date.now() / 1000)
+
+      const loginBody = urlParamsBody(1)
+      const encPassword = loginBody['enc_password'] ?? ''
+
+      expect(encPassword).toMatch(/^#PWD_INSTAGRAM:4:\d+:.+/)
+      const parts = encPassword.split(':')
+      const ts = Number(parts[2])
+      expect(ts).toBeGreaterThanOrEqual(before)
+      expect(ts).toBeLessThanOrEqual(after)
+      expect(parts[3]).toBeTruthy()
+      expect(() => Buffer.from(parts[3] ?? '', 'base64')).not.toThrow()
+    })
+  })
+
+  describe('buildHeaders', () => {
+    test('includes required Instagram headers', async () => {
+      fetchResponses.push(new Response(null, { status: 200, headers: {} }))
+      fetchResponses.push(jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }))
+
+      const client = new InstagramClient()
+      await client.authenticate('user', 'pass')
+
+      const headers = fetchCalls[0]?.init?.headers as Record<string, string>
+
+      expect(headers['X-IG-App-ID']).toBe('567067343352427')
+      expect(headers['User-Agent']).toMatch(/^Instagram \d+\.\d+\.\d+\.\d+\.\d+ Android \(/)
+      expect(headers['X-IG-Capabilities']).toBeTruthy()
+      expect(headers['X-IG-Connection-Type']).toBe('WIFI')
+      expect(headers['Content-Type']).toContain('application/x-www-form-urlencoded')
+    })
+
+    test('includes device headers when session is set', async () => {
+      fetchResponses.push(jsonResponse({ status: 'ok', inbox: { threads: [] } }))
+
+      const client = await loadedClient()
+      await client.listChats()
+
+      const headers = fetchCalls[0]?.init?.headers as Record<string, string>
+
+      expect(headers['X-IG-Device-ID']).toBe(SESSION.device.uuid)
+      expect(headers['X-IG-Android-ID']).toBe(SESSION.device.android_device_id)
+      expect(headers['Cookie']).toContain('sessionid=abc123')
+    })
+  })
+
+  describe('mapThread', () => {
+    test('maps API thread to InstagramChatSummary', async () => {
+      const thread = {
+        thread_id: 'thread-42',
+        thread_title: 'Team Chat',
+        thread_type: 'group',
+        users: [
+          { pk: '1', full_name: 'Alice', username: 'alice' },
+          { pk: '2', full_name: 'Bob', username: 'bob' },
+        ],
+        items: [],
+        read_state: 3,
+      }
+      fetchResponses.push(jsonResponse({ status: 'ok', inbox: { threads: [thread] } }))
+
+      const client = await loadedClient()
+      const chats = await client.listChats()
+
+      expect(chats).toHaveLength(1)
+      const chat = chats[0]!
+      expect(chat.id).toBe('thread-42')
+      expect(chat.name).toBe('Team Chat')
+      expect(chat.type).toBe('group')
+      expect(chat.is_group).toBe(true)
+      expect(chat.unread_count).toBe(3)
+      expect(chat.participant_count).toBe(3)
+    })
+
+    test('falls back to user names when no thread_title', async () => {
+      const thread = {
+        thread_id: 't-1',
+        thread_type: 'private',
+        users: [{ pk: '5', full_name: 'Charlie', username: 'charlie' }],
+        items: [],
+        read_state: 0,
+      }
+      fetchResponses.push(jsonResponse({ status: 'ok', inbox: { threads: [thread] } }))
+
+      const client = await loadedClient()
+      const chats = await client.listChats()
+
+      expect(chats[0]!.name).toBe('Charlie')
+      expect(chats[0]!.is_group).toBe(false)
+    })
+  })
+
+  describe('mapMessage', () => {
+    test('maps API item to InstagramMessageSummary with media_url', async () => {
+      const item = {
+        item_id: 'msg-7',
+        user_id: '10',
+        timestamp: 1_700_000_000_000_000,
+        item_type: 'media',
+        media: {
+          image_versions2: {
+            candidates: [{ url: 'https://cdn.example.com/photo.jpg', width: 1080, height: 720 }],
+          },
+        },
+      }
+      const thread = {
+        thread_id: 'thread-5',
+        status: 'ok',
+        items: [item],
+      }
+      fetchResponses.push(jsonResponse({ status: 'ok', thread }))
+
+      const client = await loadedClient()
+      const messages = await client.getMessages('thread-5')
+
+      expect(messages).toHaveLength(1)
+      const msg = messages[0]!
+      expect(msg.id).toBe('msg-7')
+      expect(msg.thread_id).toBe('thread-5')
+      expect(msg.from).toBe('10')
+      expect(msg.is_outgoing).toBe(false)
+      expect(msg.type).toBe('media')
+      expect(msg.media_url).toBe('https://cdn.example.com/photo.jpg')
+    })
+
+    test('sets is_outgoing true when from matches userId', async () => {
+      const item = {
+        item_id: 'msg-8',
+        user_id: '42',
+        timestamp: 1_700_000_000_000_000,
+        item_type: 'text',
+        text: 'hi',
+      }
+      fetchResponses.push(jsonResponse({ status: 'ok', thread: { thread_id: 't-1', items: [item] } }))
+
+      const client = await loadedClient()
+      const messages = await client.getMessages('t-1')
+
+      expect(messages[0]!.is_outgoing).toBe(true)
+    })
+  })
+
+  describe('request', () => {
+    test('throws rate_limited on 429', async () => {
+      fetchResponses.push(new Response('Rate limited', { status: 429 }))
+
+      const client = await loadedClient()
+
+      const err = await client.listChats().catch((e: unknown) => e)
+      expect(err).toBeInstanceOf(InstagramError)
+      expect((err as InstagramError).code).toBe('rate_limited')
+    })
+
+    test('throws on JSON parse error', async () => {
+      fetchResponses.push(new Response('not json', { status: 200 }))
+
+      const client = await loadedClient()
+
+      await expect(client.listChats()).rejects.toThrow(InstagramError)
+    })
+
+    test('returns parsed response on success', async () => {
+      fetchResponses.push(jsonResponse({ status: 'ok', inbox: { threads: [] } }))
+
+      const client = await loadedClient()
+      const chats = await client.listChats()
+
+      expect(chats).toEqual([])
+    })
+  })
+
+  describe('searchUsers', () => {
+    test('maps response to user list', async () => {
+      fetchResponses.push(
+        jsonResponse({
+          status: 'ok',
+          users: [
+            { pk: 101, username: 'alice', full_name: 'Alice Smith' },
+            { pk: 102, username: 'bob', full_name: 'Bob Jones' },
+          ],
+        }),
+      )
+
+      const client = await loadedClient()
+      const users = await client.searchUsers('ali')
+
+      expect(users).toHaveLength(2)
+      expect(users[0]).toEqual({ pk: '101', username: 'alice', fullName: 'Alice Smith' })
+      expect(users[1]).toEqual({ pk: '102', username: 'bob', fullName: 'Bob Jones' })
+    })
+  })
+
+  describe('sendMessage', () => {
+    test('sends correct body params', async () => {
+      fetchResponses.push(
+        jsonResponse({
+          status: 'ok',
+          payload: { items: [] },
+        }),
+      )
+
+      const client = await loadedClient()
+      await client.sendMessage('thread-99', 'Hello World')
+
+      const body = urlParamsBody(0)
+      expect(body['thread_ids']).toBe('[thread-99]')
+      expect(body['text']).toBe('Hello World')
+      expect(body['action']).toBe('send_item')
+      expect(body['client_context']).toBeTruthy()
+    })
+  })
+
+  describe('sendMessageToUser', () => {
+    test('sends correct body params', async () => {
+      fetchResponses.push(
+        jsonResponse({
+          status: 'ok',
+          payload: { thread_id: 'new-thread', items: [] },
+        }),
+      )
+
+      const client = await loadedClient()
+      await client.sendMessageToUser('user-55', 'Hey there')
+
+      const body = urlParamsBody(0)
+      expect(body['recipient_users']).toBe('[[user-55]]')
+      expect(body['text']).toBe('Hey there')
+      expect(body['action']).toBe('send_item')
+      expect(body['client_context']).toBeTruthy()
+    })
+  })
+})