agent-messenger 2.33.0 → 2.35.0

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

@@ -144,6 +144,61 @@ describe('KakaoTalkClient', () => {
         expect((e as KakaoTalkError).code).toBe('missing_user_id')
       }
     })
+
+    it('preserves invalid_access_token and never continues to LCHATLIST', async () => {
+      mockLogin.mockRejectedValue(
+        Object.assign(new Error('KakaoTalk LOGINLIST invalid access token (status -950)'), {
+          code: 'invalid_access_token',
+          serverStatus: -950,
+        }),
+      )
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'expired-access-token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      let error: unknown
+      try {
+        await client.getChats({ all: true })
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({ code: 'invalid_access_token', serverStatus: -950 })
+      expect(mockGetChatList).not.toHaveBeenCalled()
+      expect(mockClose).toHaveBeenCalledTimes(1)
+    })
+
+    it('preserves other typed LOGINLIST rejections', async () => {
+      mockLogin.mockRejectedValue(
+        Object.assign(new Error('KakaoTalk LOGINLIST rejected (status -777)'), {
+          code: 'login_rejected',
+          serverStatus: -777,
+        }),
+      )
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'rejected-access-token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      await expect(client.getChats()).rejects.toMatchObject({ code: 'login_rejected', serverStatus: -777 })
+      expect(mockGetChatList).not.toHaveBeenCalled()
+    })
+
+    it('keeps interrupted LOGINLIST connections classified as login_failed', async () => {
+      mockLogin.mockRejectedValue(new Error('KakaoTalk LOGINLIST transport failed: connection closed'))
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      await expect(client.getChats()).rejects.toMatchObject({ code: 'login_failed' })
+      expect(mockGetChatList).not.toHaveBeenCalled()
+    })
   })
 
   describe('getChats', () => {

package/src/platforms/kakaotalk/client.ts

@@ -40,11 +40,13 @@ export type KakaoSessionEventHandler = (event: KakaoSessionEvent) => void
 
 export class KakaoTalkError extends Error {
   code: string
+  readonly serverStatus?: number
 
-  constructor(message: string, code: string, options?: { cause?: unknown }) {
+  constructor(message: string, code: string, options?: { cause?: unknown; serverStatus?: number }) {
     super(message, options)
     this.name = 'KakaoTalkError'
     this.code = code
+    this.serverStatus = options?.serverStatus
   }
 }
 
@@ -280,6 +282,17 @@ function wrapError(error: unknown, code: string): KakaoTalkError {
   return new KakaoTalkError(message, code, { cause: error })
 }
 
+function isLoginResponseError(
+  error: unknown,
+): error is Error & { code: 'invalid_access_token' | 'login_rejected'; serverStatus: number } {
+  if (!(error instanceof Error)) return false
+  const candidate = error as Error & { code?: unknown; serverStatus?: unknown }
+  return (
+    (candidate.code === 'invalid_access_token' || candidate.code === 'login_rejected') &&
+    typeof candidate.serverStatus === 'number'
+  )
+}
+
 const MAX_PAGES = 50
 
 function syncStatePath(deviceUuid: string): string {
@@ -675,7 +688,11 @@ export class KakaoTalkClient {
       return { session, loginResult }
     } catch (error) {
       session.close()
-      throw new KakaoTalkError(error instanceof Error ? error.message : String(error), 'login_failed', { cause: error })
+      const code = isLoginResponseError(error) ? error.code : 'login_failed'
+      throw new KakaoTalkError(error instanceof Error ? error.message : String(error), code, {
+        cause: error,
+        serverStatus: isLoginResponseError(error) ? error.serverStatus : undefined,
+      })
     }
   }
 

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

@@ -1,8 +1,10 @@
 import { expect, it } from 'bun:test'
 
+import type { KakaoOAuthRefreshOptions } from '@/platforms/kakaotalk/index'
 import {
   classifyKakaoChat,
   CredentialManager,
+  KakaoOAuthRefreshError,
   KakaoAccountCredentialsSchema,
   KakaoCredentialManager,
   KakaoChatSchema,
@@ -18,6 +20,7 @@ import {
   KakaoProfileSchema,
   KakaoTalkPushReadEventSchema,
   KakaoTypingResultSchema,
+  refreshKakaoOAuthToken,
 } from '@/platforms/kakaotalk/index'
 
 it('KakaoTalkClient is exported from barrel', () => {
@@ -87,3 +90,11 @@ it('KakaoLeaveChatResultSchema is exported from barrel', () => {
 it('KakaoTypingResultSchema is exported from barrel', () => {
   expect(typeof KakaoTypingResultSchema.parse).toBe('function')
 })
+
+it('Kakao OAuth refresh API is exported from barrel', () => {
+  expect(typeof refreshKakaoOAuthToken).toBe('function')
+  expect(typeof KakaoOAuthRefreshError).toBe('function')
+
+  const options: KakaoOAuthRefreshOptions = { timeoutMs: 5_000 }
+  expect(options.timeoutMs).toBe(5_000)
+})

package/src/platforms/kakaotalk/index.ts

@@ -6,6 +6,7 @@ export { KakaoTalkListener } from './listener'
 export type { PendingLoginState } from './credential-manager'
 export type {
   KakaoAccountCredentials,
+  KakaoAuthErrorCode,
   KakaoAuthMethod,
   KakaoChat,
   KakaoConfig,
@@ -54,6 +55,13 @@ export {
 } from './types'
 export { attemptLogin, generateDeviceUuid, loginFlow, registerDevice, requestPasscode } from './auth/kakao-login'
 export type { LoginCredentials } from './auth/kakao-login'
+export { KakaoOAuthRefreshError, refreshKakaoOAuthToken } from './auth/oauth-refresh'
+export type {
+  KakaoOAuthRefreshErrorCode,
+  KakaoOAuthRefreshInput,
+  KakaoOAuthRefreshOptions,
+  KakaoOAuthRefreshResult,
+} from './auth/oauth-refresh'
 export { sha1Hex } from './media-upload'
 export { detectImageDimensions } from './image-meta'
 export type { AttachmentInput, AttachmentPlan, ResolvedAttachment, SingleAttachmentKind } from './attachment-router'

package/src/platforms/kakaotalk/protocol/NOTICE.md

@@ -1,8 +1,9 @@
 # Third-Party Notices
 
-This LOCO protocol implementation was written from scratch for agent-messenger.
-The protocol knowledge used to build it comes from the following open-source
-projects and their documentation. No code was copied from these projects.
+This KakaoTalk protocol and Android authentication implementation was written
+from scratch for agent-messenger. The protocol knowledge used to build it comes
+from the following open-source projects and their documentation. No code was
+copied from these projects.
 
 ---
 
@@ -37,7 +38,21 @@ Android sub-device login flow, and connection patterns.
 - Copyright (c) 2020 storycraft
 
 Referenced for: LOCO packet format, BSON command schemas, authentication flow,
-X-VC signature algorithm, channel/chat type enumerations.
+Android OAuth refresh request/response behavior, X-VC signature algorithm,
+channel/chat type enumerations.
+
+---
+
+## KakaoForge
+
+- Repository: https://github.com/play2fly/KakaoForge
+- Reference commit: 4b774ea40b1347280fadb685415436584093118b
+- License: KakaoForge Non-Commercial / No Abuse License
+- Copyright (c) 2026 aodjo
+
+Referenced for: current Android `oauth2_token.json` request fields, client
+headers, device-id handling, and token rotation/expiry response fields. Protocol
+behavior only; no source code was copied or adapted.
 
 ---
 

package/src/platforms/kakaotalk/protocol/login-response.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'bun:test'
+
+import { validateLoginListResponse } from './login-response'
+import type { LocoPacket } from './types'
+
+function packet(statusCode: number, body: Record<string, unknown>): LocoPacket {
+  return { packetId: 1, statusCode, method: 'LOGINLIST', bodyType: 0, body }
+}
+
+function captureError(fn: () => unknown): unknown {
+  try {
+    fn()
+    return undefined
+  } catch (error) {
+    return error
+  }
+}
+
+describe('LOGINLIST response classification', () => {
+  it('accepts status=0 and returns the login snapshot', () => {
+    const body = { status: 0, chatDatas: [], eof: true }
+
+    expect(validateLoginListResponse(packet(0, body))).toBe(body)
+  })
+
+  it('accepts a successful response when body.status is omitted', () => {
+    const body = { chatDatas: [], eof: true }
+
+    expect(validateLoginListResponse(packet(0, body))).toBe(body)
+  })
+
+  it('classifies body.status=-950 as invalid_access_token', () => {
+    expect(() => validateLoginListResponse(packet(0, { status: -950 }))).toThrow(
+      expect.objectContaining({ code: 'invalid_access_token', serverStatus: -950 }),
+    )
+  })
+
+  it('classifies packet statusCode=-950 as invalid_access_token', () => {
+    expect(() => validateLoginListResponse(packet(-950, {}))).toThrow(
+      expect.objectContaining({ code: 'invalid_access_token', serverStatus: -950 }),
+    )
+  })
+
+  it('classifies an unknown non-zero body status as login_rejected', () => {
+    expect(() => validateLoginListResponse(packet(0, { status: -777 }))).toThrow(
+      expect.objectContaining({ code: 'login_rejected', serverStatus: -777 }),
+    )
+  })
+
+  it('classifies an unknown non-zero packet status as login_rejected', () => {
+    expect(() => validateLoginListResponse(packet(-777, {}))).toThrow(
+      expect.objectContaining({ code: 'login_rejected', serverStatus: -777 }),
+    )
+  })
+
+  it('keeps a synthetic socket close on the transport-error path', () => {
+    const error = captureError(() => validateLoginListResponse(packet(-1, { error: 'connection closed' })))
+
+    expect(error).toBeInstanceOf(Error)
+    expect(error).toMatchObject({ message: 'KakaoTalk LOGINLIST transport failed: connection closed' })
+    expect(error).not.toHaveProperty('code')
+    expect(error).not.toHaveProperty('serverStatus')
+  })
+})

package/src/platforms/kakaotalk/protocol/login-response.ts

@@ -0,0 +1,40 @@
+import type { KakaoAuthErrorCode } from '../types'
+import type { LoginListResponse, LocoPacket } from './types'
+
+const CONNECTION_CLOSED_STATUS = -1
+const INVALID_ACCESS_TOKEN_STATUS = -950
+
+export class KakaoLoginResponseError extends Error {
+  readonly code: KakaoAuthErrorCode
+  readonly serverStatus: number
+
+  constructor(code: KakaoAuthErrorCode, serverStatus: number) {
+    const reason = code === 'invalid_access_token' ? 'invalid access token' : 'rejected'
+    super(`KakaoTalk LOGINLIST ${reason} (status ${serverStatus})`)
+    this.name = 'KakaoLoginResponseError'
+    this.code = code
+    this.serverStatus = serverStatus
+  }
+}
+
+function isSyntheticConnectionClose(response: LocoPacket): boolean {
+  return response.statusCode === CONNECTION_CLOSED_STATUS && response.body.error === 'connection closed'
+}
+
+function throwAuthenticationError(serverStatus: number): never {
+  const code: KakaoAuthErrorCode =
+    serverStatus === INVALID_ACCESS_TOKEN_STATUS ? 'invalid_access_token' : 'login_rejected'
+  throw new KakaoLoginResponseError(code, serverStatus)
+}
+
+export function validateLoginListResponse(response: LocoPacket): LoginListResponse {
+  if (isSyntheticConnectionClose(response)) {
+    throw new Error('KakaoTalk LOGINLIST transport failed: connection closed')
+  }
+
+  const bodyStatus = typeof response.body.status === 'number' ? response.body.status : 0
+  if (bodyStatus !== 0) throwAuthenticationError(bodyStatus)
+  if (response.statusCode !== 0) throwAuthenticationError(response.statusCode)
+
+  return response.body as unknown as LoginListResponse
+}

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

@@ -15,6 +15,7 @@ import {
   getLocoDeviceConfig,
 } from './config'
 import { LocoConnection } from './connection'
+import { validateLoginListResponse } from './login-response'
 import type { BookingResponse, CheckinResponse, LoginListResponse, LocoPacket, SyncState } from './types'
 
 // LOCO opcode string emitted on the wire for typing indicator pulses.
@@ -81,27 +82,34 @@ export class LocoSession {
     const lastTokenId = syncState ? new Long(syncState.lastTokenId.low, syncState.lastTokenId.high) : Long.fromNumber(0)
     const lbk = syncState?.lbk ?? 0
 
-    const response = await this.connection.sendPacket('LOGINLIST', {
-      appVer: deviceConfig.appVersion,
-      prtVer: PROTOCOL_VERSION,
-      os: deviceConfig.os,
-      lang: LANG,
-      dtype: DTYPE,
-      duuid: deviceUuid,
-      oauthToken,
-      ntype: 0,
-      MCCMNC: MCCMNC,
-      revision: syncState?.revision ?? 0,
-      chatIds,
-      maxIds,
-      lastTokenId,
-      lbk,
-      rp: new Binary(Buffer.from([0x00, 0x00, 0xff, 0xff, 0x00, 0x00])),
-      bg: false,
-    })
-
-    this.startPing()
-    return response.body as unknown as LoginListResponse
+    try {
+      const response = await this.connection.sendPacket('LOGINLIST', {
+        appVer: deviceConfig.appVersion,
+        prtVer: PROTOCOL_VERSION,
+        os: deviceConfig.os,
+        lang: LANG,
+        dtype: DTYPE,
+        duuid: deviceUuid,
+        oauthToken,
+        ntype: 0,
+        MCCMNC: MCCMNC,
+        revision: syncState?.revision ?? 0,
+        chatIds,
+        maxIds,
+        lastTokenId,
+        lbk,
+        rp: new Binary(Buffer.from([0x00, 0x00, 0xff, 0xff, 0x00, 0x00])),
+        bg: false,
+      })
+
+      const loginResult = validateLoginListResponse(response)
+      this.startPing()
+      return loginResult
+    } catch (error) {
+      this.connection.close()
+      this.connection = null
+      throw error
+    }
   }
 
   private async bookAndCheckin(

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

@@ -36,6 +36,7 @@ export interface SyncState {
 
 // LOGINLIST uses short BSON field names: c=chatId, t=type, a=activeMembers, etc.
 export interface LoginListResponse extends ChatListResponse {
+  status?: number
   userId: number
   revision: number
 }

package/src/platforms/kakaotalk/types.ts

@@ -12,6 +12,7 @@ export interface ExtractedKakaoToken {
 }
 
 export type KakaoAuthMethod = 'login' | 'extract'
+export type KakaoAuthErrorCode = 'invalid_access_token' | 'login_rejected'
 
 export interface KakaoAccountCredentials {
   account_id: string