agent-messenger 2.7.0 → 2.9.0

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

@@ -28,7 +28,9 @@ const mockGetUser = mock((userId: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     listUsers = mockListUsers
     getUser = mockGetUser
   },

package/src/platforms/instagram/cli.ts

@@ -18,10 +18,7 @@ function isAuthCommand(command: CommandType): boolean {
 
 const program = new Command()
 
-program
-  .name('agent-instagram')
-  .description('CLI tool for Instagram DMs via private mobile API')
-  .version(pkg.version)
+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

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

@@ -104,8 +104,7 @@ describe('InstagramClient', () => {
       const mockManager = {
         getAccount: () =>
           Promise.resolve({ account_id: 'testuser', username: 'testuser', created_at: '', updated_at: '' }),
-        ensureAccountPaths: () =>
-          Promise.resolve({ account_dir: testDir, session_path: sessionPath }),
+        ensureAccountPaths: () => Promise.resolve({ account_dir: testDir, session_path: sessionPath }),
       } as any
 
       const client = new InstagramClient(mockManager)
@@ -124,9 +123,7 @@ describe('InstagramClient', () => {
           headers: {},
         }),
       )
-      fetchResponses.push(
-        jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }),
-      )
+      fetchResponses.push(jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }))
 
       const client = new InstagramClient()
       const before = Math.floor(Date.now() / 1000)
@@ -155,9 +152,7 @@ describe('InstagramClient', () => {
           }),
         }),
       )
-      fetchResponses.push(
-        jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }),
-      )
+      fetchResponses.push(jsonResponse({ status: 'ok', logged_in_user: { pk: '99' } }))
 
       const client = new InstagramClient()
       const before = Math.floor(Date.now() / 1000)

package/src/platforms/instagram/client.ts

@@ -1,6 +1,7 @@
 import { constants, createCipheriv, publicEncrypt, randomBytes, randomUUID } from 'node:crypto'
 import { existsSync } from 'node:fs'
 import { mkdir, readFile, writeFile } from 'node:fs/promises'
+
 import { InstagramCredentialManager } from './credential-manager'
 import {
   InstagramError,
@@ -164,11 +165,7 @@ export class InstagramClient {
     return { userId: this.userId ?? '' }
   }
 
-  async twoFactorLogin(
-    username: string,
-    code: string,
-    twoFactorIdentifier: string,
-  ): Promise<{ userId: string }> {
+  async twoFactorLogin(username: string, code: string, twoFactorIdentifier: string): Promise<{ userId: string }> {
     const { status, data } = await this.request('POST', '/accounts/two_factor_login/', {
       username,
       verification_code: code,
@@ -193,7 +190,10 @@ export class InstagramClient {
   ): Promise<{ contactPoint: string; stepName: string }> {
     this.ensureSession()
 
-    const { data: getData } = await this.request('GET', `${apiPath}?guid=${this.session!.device.uuid}&device_id=${this.session!.device.android_device_id}`)
+    const { data: getData } = await this.request(
+      'GET',
+      `${apiPath}?guid=${this.session!.device.uuid}&device_id=${this.session!.device.android_device_id}`,
+    )
     const stepName = (getData['step_name'] as string) ?? ''
 
     const choice = method === 'sms' ? '0' : '1'
@@ -210,10 +210,7 @@ export class InstagramClient {
     return { contactPoint, stepName: resultStep }
   }
 
-  async challengeSubmitCode(
-    apiPath: string,
-    code: string,
-  ): Promise<{ userId: string }> {
+  async challengeSubmitCode(apiPath: string, code: string): Promise<{ userId: string }> {
     this.ensureSession()
 
     const { status, data } = await this.request('POST', apiPath, {
@@ -304,9 +301,7 @@ export class InstagramClient {
   async searchChats(query: string, limit = 20): Promise<InstagramChatSummary[]> {
     const allChats = await this.listChats(Math.max(limit, 50))
     const lower = query.toLowerCase()
-    return allChats
-      .filter((c) => c.name.toLowerCase().includes(lower) || c.id.includes(query))
-      .slice(0, limit)
+    return allChats.filter((c) => c.name.toLowerCase().includes(lower) || c.id.includes(query)).slice(0, limit)
   }
 
   async searchMessages(
@@ -410,7 +405,12 @@ export class InstagramClient {
     return this.userId
   }
 
-  async getProfile(): Promise<{ user_id: string; username: string; full_name: string | null; profile_pic_url: string | null }> {
+  async getProfile(): Promise<{
+    user_id: string
+    username: string
+    full_name: string | null
+    profile_pic_url: string | null
+  }> {
     if (!this.userId) {
       throw new InstagramError('Not authenticated. Call login() first.', 'not_authenticated')
     }
@@ -441,17 +441,16 @@ export class InstagramClient {
     const keyIdHeader = response.headers.get('ig-set-password-encryption-key-id')
 
     if (pubKeyHeader && keyIdHeader) {
-      this.debugLog?.(`encryption key_id=${keyIdHeader} pub_key_length=${pubKeyHeader.length} pub_key_prefix=${pubKeyHeader.substring(0, 40)}...`)
+      this.debugLog?.(
+        `encryption key_id=${keyIdHeader} pub_key_length=${pubKeyHeader.length} pub_key_prefix=${pubKeyHeader.substring(0, 40)}...`,
+      )
       return { keyId: keyIdHeader, publicKey: pubKeyHeader }
     }
 
     return null
   }
 
-  private encryptPassword(
-    password: string,
-    key: { keyId: string; publicKey: string },
-  ): string {
+  private encryptPassword(password: string, key: { keyId: string; publicKey: string }): string {
     const timestamp = Math.floor(Date.now() / 1000).toString()
     const passwordBytes = Buffer.from(password, 'utf-8')
 
@@ -463,21 +462,24 @@ export class InstagramClient {
     const tag = cipher.getAuthTag()
 
     const pubKeyPem = Buffer.from(key.publicKey, 'base64').toString('utf-8')
-    const rsaEncrypted = publicEncrypt(
-      { key: pubKeyPem, padding: constants.RSA_PKCS1_PADDING },
-      aesKey,
-    )
+    const rsaEncrypted = publicEncrypt({ key: pubKeyPem, padding: constants.RSA_PKCS1_PADDING }, aesKey)
 
     // Wire format: version(1) | keyId(1) | iv(12) | rsaLen(2 LE) | rsaEncrypted | tag(16) | aesEncrypted
     const keyIdNum = Number.parseInt(key.keyId, 10)
     const buf = Buffer.alloc(1 + 1 + 12 + 2 + rsaEncrypted.length + 16 + encrypted.length)
     let offset = 0
-    buf.writeUInt8(1, offset); offset += 1
-    buf.writeUInt8(keyIdNum, offset); offset += 1
-    iv.copy(buf, offset); offset += 12
-    buf.writeUInt16LE(rsaEncrypted.length, offset); offset += 2
-    rsaEncrypted.copy(buf, offset); offset += rsaEncrypted.length
-    tag.copy(buf, offset); offset += 16
+    buf.writeUInt8(1, offset)
+    offset += 1
+    buf.writeUInt8(keyIdNum, offset)
+    offset += 1
+    iv.copy(buf, offset)
+    offset += 12
+    buf.writeUInt16LE(rsaEncrypted.length, offset)
+    offset += 2
+    rsaEncrypted.copy(buf, offset)
+    offset += rsaEncrypted.length
+    tag.copy(buf, offset)
+    offset += 16
     encrypted.copy(buf, offset)
 
     return `#PWD_INSTAGRAM:4:${timestamp}:${buf.toString('base64')}`
@@ -532,7 +534,7 @@ export class InstagramClient {
       'X-IG-Connection-Type': 'WIFI',
       'X-IG-Timezone-Offset': String(new Date().getTimezoneOffset() * -60),
       'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
-      'Accept': '*/*',
+      Accept: '*/*',
       'Accept-Language': 'en-US,en;q=0.9',
     }
 
@@ -606,7 +608,6 @@ export class InstagramClient {
     if (this.session) {
       this.session.user_id = this.userId ?? undefined
       this.session.cookies = this.serializeCookies()
-
     }
 
     await this.saveSession()
@@ -634,9 +635,13 @@ export class InstagramClient {
     const items = (thread['items'] ?? []) as Array<Record<string, unknown>>
     const lastItem = items[0]
 
-    const name = threadTitle
-      || users.map((u) => (u['full_name'] as string) || (u['username'] as string) || '').filter(Boolean).join(', ')
-      || threadId
+    const name =
+      threadTitle ||
+      users
+        .map((u) => (u['full_name'] as string) || (u['username'] as string) || '')
+        .filter(Boolean)
+        .join(', ') ||
+      threadId
 
     return {
       id: threadId,

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

@@ -21,8 +21,12 @@ import { authCommand } from './auth'
 
 function resetCommandState(cmd: Command): void {
   for (const sub of cmd.commands) {
-    (sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValues = {}
-    ;(sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> })._optionValueSources = {}
+    ;(
+      sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> }
+    )._optionValues = {}
+    ;(
+      sub as unknown as { _optionValues: Record<string, unknown>; _optionValueSources: Record<string, unknown> }
+    )._optionValueSources = {}
   }
 }
 
@@ -38,7 +42,8 @@ describe('auth commands', () => {
     mockSetCurrent.mockReset()
     mockRemoveAccount.mockReset()
 
-    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
     processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
       throw new Error('process.exit called')
     })
@@ -53,9 +58,7 @@ describe('auth commands', () => {
     test('outputs error and exits when no account found', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(
-        authCommand.parseAsync(['status'], { from: 'user' }),
-      ).rejects.toThrow('process.exit called')
+      await expect(authCommand.parseAsync(['status'], { from: 'user' })).rejects.toThrow('process.exit called')
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -160,9 +163,9 @@ describe('auth commands', () => {
     test('outputs error when account not found', async () => {
       mockSetCurrent.mockImplementation(() => Promise.resolve(false))
 
-      await expect(
-        authCommand.parseAsync(['use', 'missing_account'], { from: 'user' }),
-      ).rejects.toThrow('process.exit called')
+      await expect(authCommand.parseAsync(['use', 'missing_account'], { from: 'user' })).rejects.toThrow(
+        'process.exit called',
+      )
 
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output.error).toContain('missing_account')
@@ -194,9 +197,7 @@ describe('auth commands', () => {
     test('outputs error when no account configured', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(
-        authCommand.parseAsync(['logout'], { from: 'user' }),
-      ).rejects.toThrow('process.exit called')
+      await expect(authCommand.parseAsync(['logout'], { from: 'user' })).rejects.toThrow('process.exit called')
 
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
       expect(output.error).toContain('No Instagram account configured')

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

@@ -3,9 +3,11 @@ import { mkdir, writeFile } from 'node:fs/promises'
 import { Writable } from 'node:stream'
 
 import { Command } from 'commander'
+
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { info, warn, error as stderrError, debug } from '@/shared/utils/stderr'
+
 import { InstagramClient, generateAndroidDeviceId, generateDeviceString } from '../client'
 import { InstagramCredentialManager } from '../credential-manager'
 import { InstagramTokenExtractor } from '../token-extractor'
@@ -65,11 +67,16 @@ async function saveAccountAndPrint(
   })
   await manager.setCurrent(accountId)
 
-  console.log(formatOutput({
-    authenticated: true,
-    account_id: accountId,
-    username,
-  }, pretty))
+  console.log(
+    formatOutput(
+      {
+        authenticated: true,
+        account_id: accountId,
+        username,
+      },
+      pretty,
+    ),
+  )
 }
 
 interface LoginOptions {
@@ -86,24 +93,40 @@ async function loginAction(options: LoginOptions): Promise<void> {
 
     if (!username) {
       if (!interactive) {
-        console.log(formatOutput({
-          error: 'Username required. Use --username <username> --password <password>.',
-        }, options.pretty))
+        console.log(
+          formatOutput(
+            {
+              error: 'Username required. Use --username <username> --password <password>.',
+            },
+            options.pretty,
+          ),
+        )
         process.exit(1)
       }
       username = await promptText('Instagram username')
-      if (!username) { stderrError('Username is required.'); process.exit(1) }
+      if (!username) {
+        stderrError('Username is required.')
+        process.exit(1)
+      }
     }
 
     if (!password) {
       if (!interactive) {
-        console.log(formatOutput({
-          error: 'Password required. Use --username <username> --password <password>.',
-        }, options.pretty))
+        console.log(
+          formatOutput(
+            {
+              error: 'Password required. Use --username <username> --password <password>.',
+            },
+            options.pretty,
+          ),
+        )
         process.exit(1)
       }
       password = await promptHidden('Password')
-      if (!password) { stderrError('Password is required.'); process.exit(1) }
+      if (!password) {
+        stderrError('Password is required.')
+        process.exit(1)
+      }
     }
 
     const manager = new InstagramCredentialManager()
@@ -124,16 +147,25 @@ async function loginAction(options: LoginOptions): Promise<void> {
       if (interactive) {
         info('\n  Two-factor authentication required.')
         const code = await promptText('Verification code')
-        if (!code) { stderrError('Code is required.'); process.exit(1) }
+        if (!code) {
+          stderrError('Code is required.')
+          process.exit(1)
+        }
 
         const tfResult = await client.twoFactorLogin(username, code, twoFactorIdentifier)
         await saveAccountAndPrint(manager, accountId, username, tfResult.userId, options.pretty)
       } else {
-        console.log(formatOutput({
-          two_factor_required: true,
-          two_factor_identifier: twoFactorIdentifier,
-          message: 'Run "agent-instagram auth verify --username <username> --code <code> --identifier <identifier>"',
-        }, options.pretty))
+        console.log(
+          formatOutput(
+            {
+              two_factor_required: true,
+              two_factor_identifier: twoFactorIdentifier,
+              message:
+                'Run "agent-instagram auth verify --username <username> --code <code> --identifier <identifier>"',
+            },
+            options.pretty,
+          ),
+        )
       }
       return
     }
@@ -142,11 +174,17 @@ async function loginAction(options: LoginOptions): Promise<void> {
       if (interactive) {
         await handleInteractiveChallenge(client, manager, accountId, username, result.challengePath!, options.pretty)
       } else {
-        console.log(formatOutput({
-          challenge_required: true,
-          challenge_path: result.challengePath,
-          message: 'Run "agent-instagram auth challenge --username <username> --method email" then "agent-instagram auth challenge --username <username> --code <code>"',
-        }, options.pretty))
+        console.log(
+          formatOutput(
+            {
+              challenge_required: true,
+              challenge_path: result.challengePath,
+              message:
+                'Run "agent-instagram auth challenge --username <username> --method email" then "agent-instagram auth challenge --username <username> --code <code>"',
+            },
+            options.pretty,
+          ),
+        )
       }
       return
     }
@@ -172,7 +210,7 @@ async function handleInteractiveChallenge(
   info('')
 
   const choice = await promptText('Method (1/2)')
-  const method = choice === '2' ? 'sms' as const : 'email' as const
+  const method = choice === '2' ? ('sms' as const) : ('email' as const)
 
   const sendResult = await client.challengeSendCode(challengePath, method)
   if (sendResult.contactPoint) {
@@ -182,7 +220,10 @@ async function handleInteractiveChallenge(
   }
 
   const code = await promptText('Verification code')
-  if (!code) { stderrError('Code is required.'); process.exit(1) }
+  if (!code) {
+    stderrError('Code is required.')
+    process.exit(1)
+  }
 
   const verifyResult = await client.challengeSubmitCode(challengePath, code)
   await saveAccountAndPrint(manager, accountId, username, verifyResult.userId, pretty)
@@ -204,11 +245,7 @@ async function verifyAction(options: VerifyOptions): Promise<void> {
     const client = new InstagramClient(manager)
     client.setSessionPath(paths.session_path)
 
-    const result = await client.twoFactorLogin(
-      options.username,
-      options.code,
-      options.identifier,
-    )
+    const result = await client.twoFactorLogin(options.username, options.code, options.identifier)
 
     await saveAccountAndPrint(manager, accountId, options.username, result.userId, options.pretty)
   } catch (error) {
@@ -235,9 +272,14 @@ async function challengeAction(options: ChallengeOptions): Promise<void> {
 
     const challengePath = client.getChallengePath()
     if (!challengePath) {
-      console.log(formatOutput({
-        error: 'No pending challenge found. Run "agent-instagram auth login" first.',
-      }, options.pretty))
+      console.log(
+        formatOutput(
+          {
+            error: 'No pending challenge found. Run "agent-instagram auth login" first.',
+          },
+          options.pretty,
+        ),
+      )
       process.exit(1)
     }
 
@@ -248,12 +290,17 @@ async function challengeAction(options: ChallengeOptions): Promise<void> {
       const method = (options.method === 'sms' ? 'sms' : 'email') as 'email' | 'sms'
       const result = await client.challengeSendCode(challengePath, method)
 
-      console.log(formatOutput({
-        code_sent: true,
-        contact_point: result.contactPoint,
-        step_name: result.stepName,
-        message: `Verification code sent. Run "agent-instagram auth challenge --username ${options.username} --code <code>" to complete.`,
-      }, options.pretty))
+      console.log(
+        formatOutput(
+          {
+            code_sent: true,
+            contact_point: result.contactPoint,
+            step_name: result.stepName,
+            message: `Verification code sent. Run "agent-instagram auth challenge --username ${options.username} --code <code>" to complete.`,
+          },
+          options.pretty,
+        ),
+      )
     }
   } catch (error) {
     handleError(error as Error)
@@ -266,22 +313,32 @@ async function statusAction(options: { account?: string; pretty?: boolean }): Pr
     const account = await manager.getAccount(options.account)
 
     if (!account) {
-      console.log(formatOutput({
-        error: options.account
-          ? `Instagram account "${options.account}" not found.`
-          : 'No Instagram account configured. Run "auth login" first.',
-      }, options.pretty))
+      console.log(
+        formatOutput(
+          {
+            error: options.account
+              ? `Instagram account "${options.account}" not found.`
+              : 'No Instagram account configured. Run "auth login" first.',
+          },
+          options.pretty,
+        ),
+      )
       process.exit(1)
     }
 
-    console.log(formatOutput({
-      account_id: account.account_id,
-      username: account.username,
-      full_name: account.full_name,
-      pk: account.pk,
-      created_at: account.created_at,
-      updated_at: account.updated_at,
-    }, options.pretty))
+    console.log(
+      formatOutput(
+        {
+          account_id: account.account_id,
+          username: account.username,
+          full_name: account.full_name,
+          pk: account.pk,
+          created_at: account.created_at,
+          updated_at: account.updated_at,
+        },
+        options.pretty,
+      ),
+    )
   } catch (error) {
     handleError(error as Error)
   }
@@ -292,18 +349,20 @@ async function listAction(options: { pretty?: boolean }): Promise<void> {
     const manager = new InstagramCredentialManager()
     const accounts = await manager.listAccounts()
 
-    console.log(formatOutput(
-      accounts.map((account) => ({
-        account_id: account.account_id,
-        username: account.username,
-        full_name: account.full_name,
-        pk: account.pk,
-        created_at: account.created_at,
-        updated_at: account.updated_at,
-        is_current: account.is_current,
-      })),
-      options.pretty,
-    ))
+    console.log(
+      formatOutput(
+        accounts.map((account) => ({
+          account_id: account.account_id,
+          username: account.username,
+          full_name: account.full_name,
+          pk: account.pk,
+          created_at: account.created_at,
+          updated_at: account.updated_at,
+          is_current: account.is_current,
+        })),
+        options.pretty,
+      ),
+    )
   } catch (error) {
     handleError(error as Error)
   }
@@ -343,7 +402,8 @@ async function extractAction(options: { pretty?: boolean; debug?: boolean }): Pr
       console.log(
         formatOutput(
           {
-            error: 'No Instagram cookies found in any browser. Make sure you are logged in to instagram.com in Chrome, Edge, Arc, or Brave.',
+            error:
+              'No Instagram cookies found in any browser. Make sure you are logged in to instagram.com in Chrome, Edge, Arc, or Brave.',
             hint: 'Run "auth login --username <username>" to log in manually.',
           },
           options.pretty,
@@ -440,11 +500,16 @@ async function logoutAction(options: { account?: string; pretty?: boolean }): Pr
     const account = await manager.getAccount(options.account)
 
     if (!account) {
-      console.log(formatOutput({
-        error: options.account
-          ? `Instagram account "${options.account}" not found.`
-          : 'No Instagram account configured.',
-      }, options.pretty))
+      console.log(
+        formatOutput(
+          {
+            error: options.account
+              ? `Instagram account "${options.account}" not found.`
+              : 'No Instagram account configured.',
+          },
+          options.pretty,
+        ),
+      )
       process.exit(1)
     }