agent-messenger 2.7.0 → 2.9.0

package/src/platforms/kakaotalk/client.ts

@@ -1,9 +1,10 @@
-import { Long } from 'bson'
 import { existsSync } from 'node:fs'
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
+import { Long } from 'bson'
+
 import { warn } from '@/shared/utils/stderr'
 
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
@@ -312,7 +313,9 @@ export class KakaoTalkClient {
       // where a concurrent call already reconnected and replaced this.state.
       if (this.state?.session === state.session) throw error
 
-      try { state.session.close() } catch {}
+      try {
+        state.session.close()
+      } catch {}
       this.initPromise = null
       state = await this.ensureSession()
       return operation(state)
@@ -323,7 +326,13 @@ export class KakaoTalkClient {
     const session = new LocoSession()
     try {
       const syncState = await loadSyncState(this.deviceUuid!)
-      const loginResult = await session.login(this.oauthToken!, this.userId!, this.deviceUuid!, syncState, this.deviceType)
+      const loginResult = await session.login(
+        this.oauthToken!,
+        this.userId!,
+        this.deviceUuid!,
+        syncState,
+        this.deviceType,
+      )
 
       const newSyncState = mergeSyncState(syncState, loginResult)
       await saveSyncState(this.deviceUuid!, newSyncState)
@@ -338,11 +347,7 @@ export class KakaoTalkClient {
       return { session, loginResult }
     } catch (error) {
       session.close()
-      throw new KakaoTalkError(
-        error instanceof Error ? error.message : String(error),
-        'login_failed',
-        { cause: error },
-      )
+      throw new KakaoTalkError(error instanceof Error ? error.message : String(error), 'login_failed', { cause: error })
     }
   }
 
@@ -461,7 +466,10 @@ export class KakaoTalkClient {
         for (let page = 0; page < MAX_PAGES; page++) {
           const response = await session.syncMessages(cid, 80, cur, maxLogId)
           const batch = (response.body.chatLogs ?? []) as Array<Record<string, unknown>>
-          if (batch.length === 0) { reachedEnd = true; break }
+          if (batch.length === 0) {
+            reachedEnd = true
+            break
+          }
 
           for (const log of batch) {
             const lid = longToString(log.logId)
@@ -473,7 +481,10 @@ export class KakaoTalkClient {
 
           const maxLog = findMaxLogId(batch, 'logId')
 
-          if (!maxLog || maxLog.equals(cur) || response.body.isOK) { reachedEnd = true; break }
+          if (!maxLog || maxLog.equals(cur) || response.body.isOK) {
+            reachedEnd = true
+            break
+          }
           cur = maxLog
         }
         if (!reachedEnd) {
@@ -532,7 +543,7 @@ export class KakaoTalkClient {
         throw new KakaoTalkError(`Profile request failed: ${profileRes.status}`, 'profile_request_failed')
       }
 
-      const profileData = await profileRes.json() as Record<string, unknown>
+      const profileData = (await profileRes.json()) as Record<string, unknown>
       const profile = profileData.profile as Record<string, unknown> | undefined
 
       let accountDisplayId: string | null = null
@@ -540,7 +551,7 @@ export class KakaoTalkClient {
       let pstnNumber: string | null = null
       let emailVerified: boolean | null = null
       if (settingsRes.ok) {
-        const settingsData = await settingsRes.json() as Record<string, unknown>
+        const settingsData = (await settingsRes.json()) as Record<string, unknown>
         accountDisplayId = (settingsData.accountDisplayId as string) || null
         accountEmail = (settingsData.accountEmail as string) || null
         pstnNumber = (settingsData.pstnNumber as string) || null

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

@@ -2,9 +2,7 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from 'bun:
 
 const originalConsoleLog = console.log
 
-const mockLoad = mock(() =>
-  Promise.resolve({ current_account: null, accounts: {} }),
-)
+const mockLoad = mock(() => Promise.resolve({ current_account: null, accounts: {} }))
 const mockGetAccount = mock(() => Promise.resolve(null))
 const mockListAccounts = mock(() => Promise.resolve([]))
 const mockSetAccount = mock(() => Promise.resolve())
@@ -48,9 +46,7 @@ describe('auth commands', () => {
     mockRemoveAccount.mockReset()
     mockLoadPendingLogin.mockReset()
 
-    mockLoad.mockImplementation(() =>
-      Promise.resolve({ current_account: null, accounts: {} }),
-    )
+    mockLoad.mockImplementation(() => Promise.resolve({ current_account: null, accounts: {} }))
     mockGetAccount.mockImplementation(() => Promise.resolve(null))
     mockListAccounts.mockImplementation(() => Promise.resolve([]))
     mockSetAccount.mockImplementation(() => Promise.resolve())
@@ -145,9 +141,7 @@ describe('auth commands', () => {
     test('outputs error and exits when account not found', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(
-        authCommand.parseAsync(['use', 'nonexistent'], { from: 'user' }),
-      ).rejects.toThrow('process.exit')
+      await expect(authCommand.parseAsync(['use', 'nonexistent'], { from: 'user' })).rejects.toThrow('process.exit')
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -159,9 +153,7 @@ describe('auth commands', () => {
     test('outputs error and exits when no account configured', async () => {
       mockGetAccount.mockImplementation(() => Promise.resolve(null))
 
-      await expect(
-        authCommand.parseAsync(['status'], { from: 'user' }),
-      ).rejects.toThrow('process.exit')
+      await expect(authCommand.parseAsync(['status'], { from: 'user' })).rejects.toThrow('process.exit')
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
@@ -283,13 +275,9 @@ describe('auth commands', () => {
     })
 
     test('outputs error and exits when no account configured', async () => {
-      mockLoad.mockImplementation(() =>
-        Promise.resolve({ current_account: null, accounts: {} }),
-      )
+      mockLoad.mockImplementation(() => Promise.resolve({ current_account: null, accounts: {} }))
 
-      await expect(
-        authCommand.parseAsync(['logout'], { from: 'user' }),
-      ).rejects.toThrow('process.exit')
+      await expect(authCommand.parseAsync(['logout'], { from: 'user' })).rejects.toThrow('process.exit')
 
       expect(processExitSpy).toHaveBeenCalledWith(1)
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0])

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

@@ -9,12 +9,7 @@ import { info, error, debug } from '@/shared/utils/stderr'
 import { loginFlow } from '../auth/kakao-login'
 import { CredentialManager } from '../credential-manager'
 import { KakaoTokenExtractor } from '../token-extractor'
-import {
-  KAKAO_NEXT_ACTIONS,
-  type KakaoAuthOptions,
-  type KakaoDeviceType,
-  type KakaoLoginResult,
-} from '../types'
+import { KAKAO_NEXT_ACTIONS, type KakaoAuthOptions, type KakaoDeviceType, type KakaoLoginResult } from '../types'
 
 function isInteractiveSession(): boolean {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY)
@@ -28,14 +23,13 @@ function hasTTY(): boolean {
     const fd = openSync(ttyDevice, 'r')
     closeSync(fd)
     return true
-  } catch { return false }
+  } catch {
+    return false
+  }
 }
 
 async function promptPasswordGUI(email?: string): Promise<string | undefined> {
   const { execSync } = require('node:child_process') as typeof import('node:child_process')
-  const label = email
-    ? `agent-messenger wants to log in to KakaoTalk as ${email}.\\n\\nEnter your password:`
-    : 'agent-messenger wants to log in to KakaoTalk.\\n\\nEnter your password:'
 
   if (process.platform === 'darwin') {
     try {
@@ -43,9 +37,10 @@ async function promptPasswordGUI(email?: string): Promise<string | undefined> {
       const { tmpdir } = require('node:os') as typeof import('node:os')
       const { join } = require('node:path') as typeof import('node:path')
       const scriptPath = join(tmpdir(), `kakao-pw-${Date.now()}.swift`)
-      const infoText = email ? `Enter password for ${email}` : 'Enter your KakaoTalk password'
       const escapedEmail = (email ?? '').replace(/\\/g, '\\\\').replace(/"/g, '\\"')
-      writeFileSync(scriptPath, `
+      writeFileSync(
+        scriptPath,
+        `
 import AppKit
 let app = NSApplication.shared
 app.setActivationPolicy(.accessory)
@@ -88,14 +83,23 @@ if response == .alertFirstButtonReturn {
 } else {
   exit(1)
 }
-`)
+`,
+      )
       try {
-        const result = execSync(`swift ${scriptPath}`, { encoding: 'utf-8', timeout: 120_000, stdio: ['pipe', 'pipe', 'pipe'] })
+        const result = execSync(`swift ${scriptPath}`, {
+          encoding: 'utf-8',
+          timeout: 120_000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        })
         return result.trim() || undefined
       } finally {
-        try { unlinkSync(scriptPath) } catch {}
+        try {
+          unlinkSync(scriptPath)
+        } catch {}
       }
-    } catch { return undefined }
+    } catch {
+      return undefined
+    }
   }
 
   if (process.platform === 'win32') {
@@ -118,7 +122,9 @@ if response == .alertFirstButtonReturn {
       ].join(' ')
       const result = execSync(`powershell -Command "${ps}"`, { encoding: 'utf-8', timeout: 120_000 })
       return result.trim() || undefined
-    } catch { return undefined }
+    } catch {
+      return undefined
+    }
   }
 
   if (process.platform === 'linux') {
@@ -129,14 +135,18 @@ if response == .alertFirstButtonReturn {
         { encoding: 'utf-8', timeout: 120_000 },
       )
       return result.trim() || undefined
-    } catch { /* zenity not available or cancelled */ }
+    } catch {
+      /* zenity not available or cancelled */
+    }
     try {
       const result = execSync(
         `kdialog --password "agent-messenger · KakaoTalk\\n${escapedEmail}" --title "KakaoTalk Login" 2>/dev/null`,
         { encoding: 'utf-8', timeout: 120_000 },
       )
       return result.trim() || undefined
-    } catch { /* kdialog not available or cancelled */ }
+    } catch {
+      /* kdialog not available or cancelled */
+    }
   }
 
   return undefined
@@ -191,7 +201,9 @@ async function promptHiddenTTY(message: string): Promise<string | undefined> {
         stdio: ['inherit', 'pipe', 'inherit'],
       })
       return result.trim() || undefined
-    } catch { return undefined }
+    } catch {
+      return undefined
+    }
   }
 
   const { createReadStream } = await import('node:fs')
@@ -257,16 +269,26 @@ async function loginAction(options: KakaoAuthOptions): Promise<void> {
             password = await promptHidden(passwordPrompt)
           } else if (hasTTY()) {
             info(`  One-time setup: password is needed to register this device.`)
-            try { password = await promptHiddenTTY(passwordPrompt) } catch { /* /dev/tty open failed */ }
+            try {
+              password = await promptHiddenTTY(passwordPrompt)
+            } catch {
+              /* /dev/tty open failed */
+            }
           }
           if (!password) {
             password = await promptPasswordGUI(email)
           }
           if (!password) {
-            console.log(formatOutput({
-              next_action: 'run_interactive',
-              message: 'One-time device registration required. Run `agent-kakaotalk auth login` in a terminal so the user can enter their password securely.',
-            }, options.pretty))
+            console.log(
+              formatOutput(
+                {
+                  next_action: 'run_interactive',
+                  message:
+                    'One-time device registration required. Run `agent-kakaotalk auth login` in a terminal so the user can enter their password securely.',
+                },
+                options.pretty,
+              ),
+            )
             return
           }
         }
@@ -279,7 +301,10 @@ async function loginAction(options: KakaoAuthOptions): Promise<void> {
         return
       }
       email = await promptText('KakaoTalk email')
-      if (!email) { error('Email is required.'); process.exit(1) }
+      if (!email) {
+        error('Email is required.')
+        process.exit(1)
+      }
     }
 
     if (!password) {
@@ -288,7 +313,10 @@ async function loginAction(options: KakaoAuthOptions): Promise<void> {
         return
       }
       password = await promptHidden('Password')
-      if (!password) { error('Password is required.'); process.exit(1) }
+      if (!password) {
+        error('Password is required.')
+        process.exit(1)
+      }
     }
 
     const existing = await credManager.getAccount()
@@ -319,10 +347,15 @@ async function loginAction(options: KakaoAuthOptions): Promise<void> {
 
     if (result.next_action === 'choose_device') {
       if (!interactive) {
-        console.log(formatOutput({
-          ...KAKAO_NEXT_ACTIONS.choose_device,
-          warning: result.warning,
-        }, options.pretty))
+        console.log(
+          formatOutput(
+            {
+              ...KAKAO_NEXT_ACTIONS.choose_device,
+              warning: result.warning,
+            },
+            options.pretty,
+          ),
+        )
         return
       }
 
@@ -336,7 +369,10 @@ async function loginAction(options: KakaoAuthOptions): Promise<void> {
       console.log('')
 
       const choice = await promptText('Choice (1/2/3)')
-      if (choice !== '1' && choice !== '2') { console.log('Cancelled.'); return }
+      if (choice !== '1' && choice !== '2') {
+        console.log('Cancelled.')
+        return
+      }
 
       const chosenType: KakaoDeviceType = choice === '1' ? 'pc' : 'tablet'
       const forceResult = await loginFlow({
@@ -359,7 +395,15 @@ async function loginAction(options: KakaoAuthOptions): Promise<void> {
 }
 
 async function handleLoginResult(
-  result: KakaoLoginResult & { credentials?: { access_token: string; refresh_token: string; user_id: string; device_uuid: string; device_type: KakaoDeviceType } },
+  result: KakaoLoginResult & {
+    credentials?: {
+      access_token: string
+      refresh_token: string
+      user_id: string
+      device_uuid: string
+      device_type: KakaoDeviceType
+    }
+  },
   credManager: CredentialManager,
   options: KakaoAuthOptions,
 ): Promise<void> {
@@ -379,11 +423,16 @@ async function handleLoginResult(
     await credManager.setCurrentAccount(result.credentials.user_id || 'default')
     await credManager.clearPendingLogin()
 
-    console.log(formatOutput({
-      authenticated: true,
-      account_id: result.credentials.user_id,
-      device_type: result.credentials.device_type,
-    }, options.pretty))
+    console.log(
+      formatOutput(
+        {
+          authenticated: true,
+          account_id: result.credentials.user_id,
+          device_type: result.credentials.device_type,
+        },
+        options.pretty,
+      ),
+    )
   } else {
     console.log(formatOutput(result, options.pretty))
     if (result.error) process.exit(1)
@@ -444,15 +493,20 @@ async function statusAction(options: { account?: string; pretty?: boolean }): Pr
       process.exit(1)
     }
 
-    console.log(formatOutput({
-      account_id: account.account_id,
-      user_id: account.user_id,
-      device_type: account.device_type,
-      has_refresh_token: !!account.refresh_token,
-      has_device_uuid: !!account.device_uuid,
-      created_at: account.created_at,
-      updated_at: account.updated_at,
-    }, options.pretty))
+    console.log(
+      formatOutput(
+        {
+          account_id: account.account_id,
+          user_id: account.user_id,
+          device_type: account.device_type,
+          has_refresh_token: !!account.refresh_token,
+          has_device_uuid: !!account.device_uuid,
+          created_at: account.created_at,
+          updated_at: account.updated_at,
+        },
+        options.pretty,
+      ),
+    )
   } catch (error) {
     handleError(error as Error)
   }

package/src/platforms/kakaotalk/commands/chat.test.ts

@@ -2,11 +2,9 @@ import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 
 const originalConsoleLog = console.log
 
-const mockWithKakaoClient = mock(
-  async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
-    return fn(mockClient)
-  },
-)
+const mockWithKakaoClient = mock(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+  return fn(mockClient)
+})
 
 const mockGetChats = mock(() =>
   Promise.resolve([
@@ -32,11 +30,9 @@ describe('chat commands', () => {
     mockWithKakaoClient.mockReset()
     mockGetChats.mockReset()
 
-    mockWithKakaoClient.mockImplementation(
-      async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
-        return fn(mockClient)
-      },
-    )
+    mockWithKakaoClient.mockImplementation(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+      return fn(mockClient)
+    })
     mockGetChats.mockImplementation(() =>
       Promise.resolve([
         { chat_id: 'chat-1', name: 'General', type: 'group', member_count: 5 },
@@ -44,7 +40,8 @@ describe('chat commands', () => {
       ]),
     )
 
-    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
   })
 
   afterEach(() => {

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

@@ -2,21 +2,15 @@ import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 
 const originalConsoleLog = console.log
 
-const mockWithKakaoClient = mock(
-  async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
-    return fn(mockClient)
-  },
-)
+const mockWithKakaoClient = mock(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+  return fn(mockClient)
+})
 
 const mockGetMessages = mock(() =>
-  Promise.resolve([
-    { log_id: '1', message: 'Hello', sender_id: 'user-1', created_at: 1000 },
-  ]),
+  Promise.resolve([{ log_id: '1', message: 'Hello', sender_id: 'user-1', created_at: 1000 }]),
 )
 
-const mockSendMessage = mock(() =>
-  Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }),
-)
+const mockSendMessage = mock(() => Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }))
 
 const mockClient = {
   getMessages: mockGetMessages,
@@ -37,21 +31,16 @@ describe('message commands', () => {
     mockGetMessages.mockReset()
     mockSendMessage.mockReset()
 
-    mockWithKakaoClient.mockImplementation(
-      async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
-        return fn(mockClient)
-      },
-    )
+    mockWithKakaoClient.mockImplementation(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+      return fn(mockClient)
+    })
     mockGetMessages.mockImplementation(() =>
-      Promise.resolve([
-        { log_id: '1', message: 'Hello', sender_id: 'user-1', created_at: 1000 },
-      ]),
-    )
-    mockSendMessage.mockImplementation(() =>
-      Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }),
+      Promise.resolve([{ log_id: '1', message: 'Hello', sender_id: 'user-1', created_at: 1000 }]),
     )
+    mockSendMessage.mockImplementation(() => Promise.resolve({ log_id: '2', message: 'Hi there', created_at: 2000 }))
 
-    consoleLogSpy = mock((..._args: unknown[]) => {}); console.log = consoleLogSpy
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
   })
 
   afterEach(() => {
@@ -82,7 +71,9 @@ describe('message commands', () => {
     })
 
     test('passes account option to withKakaoClient', async () => {
-      await messageCommand.parseAsync(['list', 'chat-123', '--count', '20', '--account', 'my-account'], { from: 'user' })
+      await messageCommand.parseAsync(['list', 'chat-123', '--count', '20', '--account', 'my-account'], {
+        from: 'user',
+      })
 
       expect(mockWithKakaoClient).toHaveBeenCalledWith(
         expect.objectContaining({ account: 'my-account' }),

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

@@ -1,4 +1,5 @@
 import { formatOutput } from '@/shared/utils/output'
+
 import { KakaoTalkClient } from '../client'
 import { KakaoCredentialManager } from '../credential-manager'
 

package/src/platforms/kakaotalk/commands/whoami.test.ts

@@ -2,11 +2,9 @@ import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 
 const originalConsoleLog = console.log
 
-const mockWithKakaoClient = mock(
-  async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
-    return fn(mockClient)
-  },
-)
+const mockWithKakaoClient = mock(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+  return fn(mockClient)
+})
 
 const mockGetProfile = mock(() =>
   Promise.resolve({
@@ -42,11 +40,9 @@ describe('whoami command', () => {
     mockWithKakaoClient.mockReset()
     mockGetProfile.mockReset()
 
-    mockWithKakaoClient.mockImplementation(
-      async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
-        return fn(mockClient)
-      },
-    )
+    mockWithKakaoClient.mockImplementation(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+      return fn(mockClient)
+    })
     mockGetProfile.mockImplementation(() =>
       Promise.resolve({
         user_id: 'user-1',

package/src/platforms/kakaotalk/credential-manager.test.ts

@@ -8,10 +8,7 @@ import type { KakaoAccountCredentials } from './types'
 const testDirs: string[] = []
 
 function setup(): KakaoCredentialManager {
-  const testConfigDir = join(
-    import.meta.dir,
-    `.test-kakao-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  )
+  const testConfigDir = join(import.meta.dir, `.test-kakao-config-${Date.now()}-${Math.random().toString(36).slice(2)}`)
   testDirs.push(testConfigDir)
   return new KakaoCredentialManager(testConfigDir)
 }

package/src/platforms/kakaotalk/index.test.ts

@@ -1,4 +1,5 @@
 import { expect, test } from 'bun:test'
+
 import {
   CredentialManager,
   KakaoAccountCredentialsSchema,

package/src/platforms/kakaotalk/index.ts

@@ -29,5 +29,3 @@ export {
   KakaoTalkPushMessageEventSchema,
   KakaoTalkPushReadEventSchema,
 } from './types'
-
-

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

@@ -21,6 +21,7 @@ class MockLocoSession {
   close = mockSessionClose
 
   constructor() {
+    // oxlint-disable-next-line typescript-eslint/no-this-alias
     mockSessionInstance = this
   }
 
@@ -45,7 +46,12 @@ mock.module('./protocol/session', () => ({ LocoSession: MockLocoSession }))
 
 function createMockClient(overrides: Record<string, unknown> = {}) {
   return {
-    getCredentials: mock(() => ({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1', deviceType: 'tablet' as const })),
+    getCredentials: mock(() => ({
+      oauthToken: 'token',
+      userId: 'user1',
+      deviceUuid: 'device1',
+      deviceType: 'tablet' as const,
+    })),
     ...overrides,
   } as any
 }

package/src/platforms/kakaotalk/protocol/connection.ts

@@ -15,7 +15,10 @@ export class LocoConnection {
   private buffer = Buffer.alloc(0)
   private decryptedBuffer = Buffer.alloc(0)
   private packetIdCounter = 0
-  private pendingResolvers = new Map<number, { resolve: (packet: LocoPacket) => void; timer: ReturnType<typeof setTimeout> }>()
+  private pendingResolvers = new Map<
+    number,
+    { resolve: (packet: LocoPacket) => void; timer: ReturnType<typeof setTimeout> }
+  >()
   private timedOutIds = new Set<number>()
   private pushHandler: ((packet: LocoPacket) => void) | null = null
   private closeHandler: (() => void) | null = null

package/src/platforms/kakaotalk/protocol/crypto.ts

@@ -1,5 +1,6 @@
 import { constants, createCipheriv, createDecipheriv, createPublicKey, publicEncrypt, randomBytes } from 'node:crypto'
 
+import { LOCO_RSA_PUBLIC_KEY_DER_B64 } from './config'
 import {
   GCM_NONCE_SIZE,
   GCM_TAG_SIZE,
@@ -7,7 +8,6 @@ import {
   HANDSHAKE_KEY_ENCRYPT_TYPE,
   HANDSHAKE_KEY_SIZE,
 } from './types'
-import { LOCO_RSA_PUBLIC_KEY_DER_B64 } from './config'
 
 export class LocoCrypto {
   private aesKey: Buffer