agent-messenger 2.7.0 → 2.8.0

package/src/platforms/discord/token-extractor.ts

@@ -1,9 +1,17 @@
 import { execSync, spawn } from 'node:child_process'
-import { createDecipheriv, pbkdf2Sync } from 'node:crypto'
+import { pbkdf2Sync } from 'node:crypto'
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
+import {
+  BROWSER_KEYCHAIN_VARIANTS,
+  CHROMIUM_BROWSERS,
+  ChromiumCookieDecryptor,
+  discoverBrowserProfileDirs,
+  getBrowserBasePath,
+} from '@/shared/chromium'
+import type { KeychainVariant } from '@/shared/chromium'
 import { DerivedKeyCache } from '@/shared/utils/derived-key-cache'
 import { lookupLinuxKeyringPassword } from '@/shared/utils/linux-keyring'
 
@@ -13,11 +21,6 @@ export interface ExtractedDiscordToken {
 
 export type DiscordVariant = 'stable' | 'canary' | 'ptb'
 
-interface KeychainVariant {
-  service: string
-  account: string
-}
-
 interface CDPTarget {
   id: string
   type: string
@@ -34,13 +37,6 @@ interface CDPMessage {
   error?: { code: number; message: string }
 }
 
-interface BrowserConfig {
-  name: string
-  darwin: string
-  linux: string
-  win32: string
-}
-
 const TOKEN_REGEX = /[\w-]{24,}\.[\w-]{6}\.[\w-]{25,110}/
 const MFA_TOKEN_REGEX = /mfa\.[\w-]{84}/
 const ENCRYPTED_PREFIX = 'dQw4w9WgXcQ:'
@@ -62,49 +58,13 @@ const DISCORD_APP_PATHS: Record<DiscordVariant, { darwin: string }> = {
   ptb: { darwin: '/Applications/Discord PTB.app/Contents/MacOS/Discord PTB' },
 }
 
-const BROWSERS: BrowserConfig[] = [
-  {
-    name: 'Chrome',
-    darwin: join('Google', 'Chrome'),
-    linux: 'google-chrome',
-    win32: join('Google', 'Chrome', 'User Data'),
-  },
-  {
-    name: 'Chrome Canary',
-    darwin: join('Google', 'Chrome Canary'),
-    linux: 'google-chrome-unstable',
-    win32: join('Google', 'Chrome SxS', 'User Data'),
-  },
-  {
-    name: 'Edge',
-    darwin: 'Microsoft Edge',
-    linux: 'microsoft-edge',
-    win32: join('Microsoft', 'Edge', 'User Data'),
-  },
-  {
-    name: 'Arc',
-    darwin: join('Arc', 'User Data'),
-    linux: '',
-    win32: join('Arc', 'User Data'),
-  },
-  {
-    name: 'Brave',
-    darwin: join('BraveSoftware', 'Brave-Browser'),
-    linux: join('BraveSoftware', 'Brave-Browser'),
-    win32: join('BraveSoftware', 'Brave-Browser', 'User Data'),
-  },
-  {
-    name: 'Vivaldi',
-    darwin: 'Vivaldi',
-    linux: 'vivaldi',
-    win32: join('Vivaldi', 'User Data'),
-  },
-  {
-    name: 'Chromium',
-    darwin: 'Chromium',
-    linux: 'chromium',
-    win32: join('Chromium', 'User Data'),
-  },
+const DISCORD_APP_KEYCHAIN_VARIANTS: KeychainVariant[] = [
+  { service: 'discord Safe Storage', account: 'discord Key' },
+  { service: 'discordcanary Safe Storage', account: 'discordcanary Key' },
+  { service: 'discordptb Safe Storage', account: 'discordptb Key' },
+  { service: 'Discord Safe Storage', account: 'Discord' },
+  { service: 'Discord Canary Safe Storage', account: 'Discord Canary' },
+  { service: 'Discord PTB Safe Storage', account: 'Discord PTB' },
 ]
 
 export class DiscordTokenExtractor {
@@ -113,12 +73,20 @@ export class DiscordTokenExtractor {
   private killWait: number
   private keyCache: DerivedKeyCache
   private cachedKey: Buffer | null = null
+  private decryptor: ChromiumCookieDecryptor
 
   constructor(platform?: NodeJS.Platform, startupWait?: number, killWait?: number, keyCache?: DerivedKeyCache) {
     this.platform = platform ?? process.platform
     this.startupWait = startupWait ?? DISCORD_STARTUP_WAIT
     this.killWait = killWait ?? 1000
     this.keyCache = keyCache ?? new DerivedKeyCache()
+    this.decryptor = new ChromiumCookieDecryptor({
+      platform: this.platform,
+      appKeychainVariants: DISCORD_APP_KEYCHAIN_VARIANTS,
+      keyCache: this.keyCache,
+      keyCachePlatform: 'discord',
+      linuxKeyringAppNames: ['discord', 'Discord'],
+    })
   }
 
   getDiscordDirs(): string[] {
@@ -147,11 +115,11 @@ export class DiscordTokenExtractor {
   getBrowserLevelDBDirs(): string[] {
     const dirs: string[] = []
 
-    for (const browser of BROWSERS) {
-      const browserBase = this.getBrowserBasePath(browser)
+    for (const browser of CHROMIUM_BROWSERS) {
+      const browserBase = getBrowserBasePath(browser, this.platform)
       if (!browserBase) continue
 
-      const profileDirs = this.discoverProfileDirs(browserBase)
+      const profileDirs = discoverBrowserProfileDirs(browserBase)
       for (const profileDir of profileDirs) {
         dirs.push(join(profileDir, 'Local Storage', 'leveldb'))
       }
@@ -160,49 +128,6 @@ export class DiscordTokenExtractor {
     return dirs
   }
 
-  private getBrowserBasePath(browser: BrowserConfig): string | null {
-    let relative: string
-
-    switch (this.platform) {
-      case 'darwin':
-        relative = browser.darwin
-        if (!relative) return null
-        return join(homedir(), 'Library', 'Application Support', relative)
-      case 'linux':
-        relative = browser.linux
-        if (!relative) return null
-        return join(homedir(), '.config', relative)
-      case 'win32':
-        relative = browser.win32
-        if (!relative) return null
-        return join(
-          process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local'),
-          relative,
-        )
-      default:
-        return null
-    }
-  }
-
-  private discoverProfileDirs(browserBase: string): string[] {
-    const dirs: string[] = []
-
-    dirs.push(join(browserBase, 'Default'))
-
-    if (!existsSync(browserBase)) return dirs
-
-    try {
-      const entries = readdirSync(browserBase, { withFileTypes: true })
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        if (!/^Profile \d+$/i.test(entry.name)) continue
-        dirs.push(join(browserBase, entry.name))
-      }
-    } catch {}
-
-    return dirs
-  }
-
   private findBrowserBaseDirForPath(path: string): string | null {
     const parts = path.split(/[/\\]/)
     for (let levels = 2; levels <= 5; levels++) {
@@ -214,24 +139,7 @@ export class DiscordTokenExtractor {
   }
 
   getKeychainVariants(): KeychainVariant[] {
-    return [
-      // Modern Discord (lowercase)
-      { service: 'discord Safe Storage', account: 'discord Key' },
-      { service: 'discordcanary Safe Storage', account: 'discordcanary Key' },
-      { service: 'discordptb Safe Storage', account: 'discordptb Key' },
-      // Legacy Discord (capitalized)
-      { service: 'Discord Safe Storage', account: 'Discord' },
-      { service: 'Discord Canary Safe Storage', account: 'Discord Canary' },
-      { service: 'Discord PTB Safe Storage', account: 'Discord PTB' },
-      // Browser keychain entries for fallback
-      { service: 'Chrome Safe Storage', account: 'Chrome' },
-      { service: 'Chrome Canary Safe Storage', account: 'Chrome Canary' },
-      { service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' },
-      { service: 'Arc Safe Storage', account: 'Arc' },
-      { service: 'Brave Safe Storage', account: 'Brave' },
-      { service: 'Vivaldi Safe Storage', account: 'Vivaldi' },
-      { service: 'Chromium Safe Storage', account: 'Chromium' },
-    ]
+    return [...DISCORD_APP_KEYCHAIN_VARIANTS, ...BROWSER_KEYCHAIN_VARIANTS]
   }
 
   getVariantFromPath(path: string): DiscordVariant {
@@ -283,6 +191,8 @@ export class DiscordTokenExtractor {
   private async loadCachedKey(): Promise<void> {
     if (this.platform !== 'darwin') return
 
+    await this.decryptor.loadCachedKey()
+
     const cached = await this.keyCache.get('discord')
     if (cached) {
       this.cachedKey = cached
@@ -290,7 +200,7 @@ export class DiscordTokenExtractor {
   }
 
   async clearKeyCache(): Promise<void> {
-    await this.keyCache.clear('discord')
+    await this.decryptor.clearKeyCache()
     this.cachedKey = null
   }
 
@@ -445,27 +355,10 @@ export class DiscordTokenExtractor {
       const encryptedKey = Buffer.from(localState.os_crypt.encrypted_key, 'base64')
 
       const dpapiBlobKey = encryptedKey.subarray(5)
-      const masterKey = this.decryptDPAPI(dpapiBlobKey)
+      const masterKey = this.decryptor.decryptDPAPI(dpapiBlobKey)
       if (!masterKey) return null
 
-      return this.decryptAESGCM(encryptedData, masterKey)
-    } catch {
-      return null
-    }
-  }
-
-  private decryptDPAPI(encryptedBlob: Buffer): Buffer | null {
-    try {
-      const b64 = encryptedBlob.toString('base64')
-      const psScript = `
-        Add-Type -AssemblyName System.Security
-        $bytes = [Convert]::FromBase64String('${b64}')
-        $decrypted = [Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
-        [Convert]::ToBase64String($decrypted)
-      `.replace(/\n/g, ' ')
-
-      const result = execSync(`powershell -Command "${psScript}"`, { encoding: 'utf8' })
-      return Buffer.from(result.trim(), 'base64')
+      return this.decryptor.decryptAESGCM(encryptedData, masterKey)
     } catch {
       return null
     }
@@ -473,7 +366,7 @@ export class DiscordTokenExtractor {
 
   private decryptMacToken(encryptedData: Buffer, discordDir: string): string | null {
     if (this.cachedKey) {
-      const decrypted = this.decryptAESCBC(encryptedData, this.cachedKey)
+      const decrypted = this.decryptor.decryptAESCBC(encryptedData, this.cachedKey)
       if (decrypted && this.isValidToken(decrypted)) return decrypted
     }
 
@@ -500,7 +393,7 @@ export class DiscordTokenExtractor {
         ).trim()
 
         const key = pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1')
-        const decrypted = this.decryptAESCBC(encryptedData, key)
+        const decrypted = this.decryptor.decryptAESCBC(encryptedData, key)
         if (decrypted && this.isValidToken(decrypted)) {
           this.cachedKey = key
           this.keyCache.set('discord', key).catch(() => {})
@@ -514,63 +407,26 @@ export class DiscordTokenExtractor {
 
   private decryptLinuxToken(encryptedData: Buffer): string | null {
     const prefix = encryptedData.subarray(0, 3).toString()
+
     if (prefix === 'v11') {
-      const result = this.decryptV11LinuxToken(encryptedData)
-      if (result) return result
+      for (const appName of ['discord', 'Discord']) {
+        try {
+          const keyringPassword = this.getLinuxKeyringPassword(appName)
+          const key = pbkdf2Sync(keyringPassword, 'saltysalt', 1, 16, 'sha1')
+          const decrypted = this.decryptor.decryptAESCBC(encryptedData, key)
+          if (decrypted) return decrypted
+        } catch {}
+      }
     }
-    // v10 or fallback
+
     const key = pbkdf2Sync('peanuts', 'saltysalt', 1, 16, 'sha1')
-    return this.decryptAESCBC(encryptedData, key)
+    return this.decryptor.decryptAESCBC(encryptedData, key)
   }
 
   private getLinuxKeyringPassword(appName: string): string {
     return lookupLinuxKeyringPassword(appName)
   }
 
-  private decryptV11LinuxToken(encryptedData: Buffer): string | null {
-    const appNames = ['discord', 'Discord']
-    for (const appName of appNames) {
-      try {
-        const keyringPassword = this.getLinuxKeyringPassword(appName)
-        const key = pbkdf2Sync(keyringPassword, 'saltysalt', 1, 16, 'sha1')
-        const result = this.decryptAESCBC(encryptedData, key)
-        if (result) return result
-      } catch {}
-    }
-    return null
-  }
-
-  private decryptAESCBC(encryptedData: Buffer, key: Buffer): string | null {
-    try {
-      const ciphertext = encryptedData.subarray(3)
-      const iv = Buffer.alloc(16, 0x20)
-
-      const decipher = createDecipheriv('aes-128-cbc', key, iv)
-      decipher.setAutoPadding(true)
-
-      const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()])
-      return decrypted.toString('utf8')
-    } catch {
-      return null
-    }
-  }
-
-  private decryptAESGCM(encryptedData: Buffer, key: Buffer): string | null {
-    try {
-      const iv = encryptedData.subarray(3, 15)
-      const authTag = encryptedData.subarray(-16)
-      const ciphertext = encryptedData.subarray(15, -16)
-
-      const decipher = createDecipheriv('aes-256-gcm', key, iv)
-      decipher.setAuthTag(authTag)
-
-      const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()])
-      return decrypted.toString('utf8')
-    } catch {
-      return null
-    }
-  }
-
   async isDiscordRunning(variant?: DiscordVariant): Promise<boolean> {
     const variants = variant ? [variant] : (['stable', 'canary', 'ptb'] as DiscordVariant[])
 

package/src/platforms/discordbot/client.ts

@@ -31,10 +31,7 @@ export class DiscordBotClient {
     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',
-      )
+      throw new DiscordBotError('No Discord bot credentials found. Run "auth set <token>" first.', 'no_credentials')
     }
     return this.login({ token: creds.token })
   }

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

@@ -21,7 +21,9 @@ const mockListGuilds = mock(() =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     testAuth = mockTestAuth
     listGuilds = mockListGuilds
   },

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

@@ -31,7 +31,9 @@ const mockResolveChannel = mock((_guildId: string, channel: string) => {
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     listChannels = mockListChannels
     getChannel = mockGetChannel
     resolveChannel = mockResolveChannel

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

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

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

@@ -22,7 +22,9 @@ const mockGetGuild = mock((guildId: string) =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     listGuilds = mockListGuilds
     getGuild = mockGetGuild
   },

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

@@ -41,7 +41,9 @@ const mockListUsers = mock((_guildId: string) =>
 
 mock.module('../client', () => ({
   DiscordBotClient: class MockDiscordBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     listChannels = mockListChannels
     getMessages = mockGetMessages
     listUsers = mockListUsers

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

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

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,