agent-messenger 2.6.3 → 2.8.0

package/src/platforms/kakaotalk/auth/kakao-login.ts

@@ -28,7 +28,7 @@ function computeXVC(email: string): string {
 function buildHeaders(email: string): Record<string, string> {
   return {
     'Content-Type': 'application/x-www-form-urlencoded',
-    'A': ANDROID_AGENT,
+    A: ANDROID_AGENT,
     'User-Agent': ANDROID_USER_AGENT,
     'Accept-Language': 'ko',
     'X-VC': computeXVC(email),
@@ -112,9 +112,10 @@ export async function attemptLogin(
     return {
       authenticated: false,
       error: 'bad_credentials',
-      message: typeof data.message === 'string'
-        ? `Login failed: ${data.message}`
-        : 'Login failed: incorrect email or password.',
+      message:
+        typeof data.message === 'string'
+          ? `Login failed: ${data.message}`
+          : 'Login failed: incorrect email or password.',
     }
   }
 
@@ -155,7 +156,11 @@ export async function requestPasscode(email: string, password: string, deviceUui
   })
 
   if (!response.ok) {
-    return { authenticated: false, error: 'passcode_request_failed', message: `HTTP ${response.status} from passcode endpoint` }
+    return {
+      authenticated: false,
+      error: 'passcode_request_failed',
+      message: `HTTP ${response.status} from passcode endpoint`,
+    }
   }
 
   const data = (await response.json()) as { status?: number; passcode?: string; remainingSeconds?: number }
@@ -202,7 +207,11 @@ export async function registerDevice(
     })
 
     if (!response.ok) {
-      return { authenticated: false, error: 'registration_failed', message: `HTTP ${response.status} from register endpoint` }
+      return {
+        authenticated: false,
+        error: 'registration_failed',
+        message: `HTTP ${response.status} from register endpoint`,
+      }
     }
 
     const data = (await response.json()) as {
@@ -248,7 +257,14 @@ export async function loginFlow(options: {
   const forced = options.force ?? false
 
   // Step 1: Try login (forced:false for tablet-first safe attempt)
-  const loginResult = await attemptLogin(options.email, options.password, deviceUuid, deviceType, forced, options.debugLog)
+  const loginResult = await attemptLogin(
+    options.email,
+    options.password,
+    deviceUuid,
+    deviceType,
+    forced,
+    options.debugLog,
+  )
 
   if (loginResult.authenticated) {
     return loginResult
@@ -261,7 +277,13 @@ export async function loginFlow(options: {
     if (passcodeResult.error) {
       return {
         ...passcodeResult,
-        credentials: { access_token: '', refresh_token: '', user_id: '', device_uuid: deviceUuid, device_type: deviceType },
+        credentials: {
+          access_token: '',
+          refresh_token: '',
+          user_id: '',
+          device_uuid: deviceUuid,
+          device_type: deviceType,
+        },
       }
     }
 

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

@@ -478,17 +478,23 @@ describe('KakaoTalkClient', () => {
 
     test('returns profile data on success', async () => {
       mockFetch
-        .mockResolvedValueOnce(makeJsonResponse({
-          profile: {
-            nickName: 'Test User',
-            profileImageUrl: 'https://example.com/profile.jpg',
-            originalProfileImageUrl: 'https://example.com/original.jpg',
-            statusMessage: 'Hello world',
-          },
-        }))
+        .mockResolvedValueOnce(
+          makeJsonResponse({
+            profile: {
+              nickName: 'Test User',
+              profileImageUrl: 'https://example.com/profile.jpg',
+              originalProfileImageUrl: 'https://example.com/original.jpg',
+              statusMessage: 'Hello world',
+            },
+          }),
+        )
         .mockResolvedValueOnce(makeJsonResponse({ accountDisplayId: 'testuser123' }))
 
-      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'mytoken',
+        userId: 'user42',
+        deviceUuid: 'device1',
+      })
       const profile = await client.getProfile()
 
       expect(profile.user_id).toBe('user42')
@@ -517,7 +523,11 @@ describe('KakaoTalkClient', () => {
         .mockResolvedValueOnce(makeJsonResponse({}, 401))
         .mockResolvedValueOnce(makeJsonResponse({ accountDisplayId: null }))
 
-      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'mytoken',
+        userId: 'user42',
+        deviceUuid: 'device1',
+      })
       try {
         await client.getProfile()
         expect.unreachable('should have thrown')
@@ -531,17 +541,23 @@ describe('KakaoTalkClient', () => {
 
     test('returns null account_display_id when more_settings request fails', async () => {
       mockFetch
-        .mockResolvedValueOnce(makeJsonResponse({
-          profile: {
-            nickName: 'Test User',
-            profileImageUrl: null,
-            originalProfileImageUrl: null,
-            statusMessage: null,
-          },
-        }))
+        .mockResolvedValueOnce(
+          makeJsonResponse({
+            profile: {
+              nickName: 'Test User',
+              profileImageUrl: null,
+              originalProfileImageUrl: null,
+              statusMessage: null,
+            },
+          }),
+        )
         .mockResolvedValueOnce(makeJsonResponse({}, 500))
 
-      const client = await new KakaoTalkClient().login({ oauthToken: 'mytoken', userId: 'user42', deviceUuid: 'device1' })
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'mytoken',
+        userId: 'user42',
+        deviceUuid: 'device1',
+      })
       const profile = await client.getProfile()
 
       expect(profile.user_id).toBe('user42')
@@ -582,9 +598,7 @@ describe('KakaoTalkClient', () => {
 
     test('concurrent calls share a single login', async () => {
       // Make login take some time
-      mockLogin.mockImplementation(
-        () => new Promise((resolve) => setTimeout(() => resolve(DEFAULT_LOGIN_RESULT), 50)),
-      )
+      mockLogin.mockImplementation(() => new Promise((resolve) => setTimeout(() => resolve(DEFAULT_LOGIN_RESULT), 50)))
       mockGetChatLogs.mockResolvedValue({
         body: { status: 0, chatLogs: [], eof: true },
       })
@@ -598,9 +612,7 @@ describe('KakaoTalkClient', () => {
     })
 
     test('retries login after failure', async () => {
-      mockLogin
-        .mockRejectedValueOnce(new Error('Connection refused'))
-        .mockResolvedValueOnce(DEFAULT_LOGIN_RESULT)
+      mockLogin.mockRejectedValueOnce(new Error('Connection refused')).mockResolvedValueOnce(DEFAULT_LOGIN_RESULT)
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
 

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(() => {