agent-messenger 2.32.0 → 2.32.2

package/src/platforms/discord/types.test.ts

@@ -2,6 +2,7 @@ import { expect, it } from 'bun:test'
 
 import {
   DiscordChannelSchema,
+  DiscordChannelType,
   DiscordConfigSchema,
   DiscordCredentialsSchema,
   DiscordError,
@@ -10,6 +11,8 @@ import {
   DiscordMessageSchema,
   DiscordReactionSchema,
   DiscordUserSchema,
+  isListableChannel,
+  isMessageReadableChannel,
 } from './types'
 
 it('DiscordGuildSchema validates correct guild', () => {
@@ -255,3 +258,45 @@ it('DiscordError is instance of Error', () => {
   const error = new DiscordError('Test error', 'TEST_CODE')
   expect(error instanceof Error).toBe(true)
 })
+
+it('isListableChannel includes text, announcement, voice, stage, forum, media, and directory', () => {
+  const listable = [
+    DiscordChannelType.GUILD_TEXT,
+    DiscordChannelType.GUILD_ANNOUNCEMENT,
+    DiscordChannelType.GUILD_VOICE,
+    DiscordChannelType.GUILD_STAGE_VOICE,
+    DiscordChannelType.GUILD_FORUM,
+    DiscordChannelType.GUILD_MEDIA,
+    DiscordChannelType.GUILD_DIRECTORY,
+  ]
+  expect(listable.every((type) => isListableChannel({ type }))).toBe(true)
+})
+
+it('isListableChannel excludes categories and threads', () => {
+  const excluded = [
+    DiscordChannelType.GUILD_CATEGORY,
+    DiscordChannelType.ANNOUNCEMENT_THREAD,
+    DiscordChannelType.PUBLIC_THREAD,
+    DiscordChannelType.PRIVATE_THREAD,
+  ]
+  expect(excluded.some((type) => isListableChannel({ type }))).toBe(false)
+})
+
+it('isMessageReadableChannel includes text, announcement, voice, and stage', () => {
+  const readable = [
+    DiscordChannelType.GUILD_TEXT,
+    DiscordChannelType.GUILD_ANNOUNCEMENT,
+    DiscordChannelType.GUILD_VOICE,
+    DiscordChannelType.GUILD_STAGE_VOICE,
+  ]
+  expect(readable.every((type) => isMessageReadableChannel({ type }))).toBe(true)
+})
+
+it('isMessageReadableChannel excludes forum, media, and directory containers', () => {
+  const notReadable = [
+    DiscordChannelType.GUILD_FORUM,
+    DiscordChannelType.GUILD_MEDIA,
+    DiscordChannelType.GUILD_DIRECTORY,
+  ]
+  expect(notReadable.some((type) => isMessageReadableChannel({ type }))).toBe(false)
+})

package/src/platforms/discord/types.ts

@@ -27,6 +27,47 @@ export interface DiscordChannel {
   }
 }
 
+// https://discord.com/developers/docs/resources/channel#channel-object-channel-types
+export const DiscordChannelType = {
+  GUILD_TEXT: 0,
+  DM: 1,
+  GUILD_VOICE: 2,
+  GROUP_DM: 3,
+  GUILD_CATEGORY: 4,
+  GUILD_ANNOUNCEMENT: 5,
+  ANNOUNCEMENT_THREAD: 10,
+  PUBLIC_THREAD: 11,
+  PRIVATE_THREAD: 12,
+  GUILD_STAGE_VOICE: 13,
+  GUILD_DIRECTORY: 14,
+  GUILD_FORUM: 15,
+  GUILD_MEDIA: 16,
+} as const
+
+const THREAD_CHANNEL_TYPES: ReadonlySet<number> = new Set([
+  DiscordChannelType.ANNOUNCEMENT_THREAD,
+  DiscordChannelType.PUBLIC_THREAD,
+  DiscordChannelType.PRIVATE_THREAD,
+])
+
+// Channels with no directly fetchable message timeline:
+// forum/media messages live in child posts/threads, and directory channels
+// are hub listings, not message channels. Fetching messages from these aborts.
+const NON_MESSAGE_CHANNEL_TYPES: ReadonlySet<number> = new Set([
+  DiscordChannelType.GUILD_FORUM,
+  DiscordChannelType.GUILD_MEDIA,
+  DiscordChannelType.GUILD_DIRECTORY,
+])
+
+// Voice/stage channels are listed too because they carry embedded text chat.
+export function isListableChannel(channel: Pick<DiscordChannel, 'type'>): boolean {
+  return channel.type !== DiscordChannelType.GUILD_CATEGORY && !THREAD_CHANNEL_TYPES.has(channel.type)
+}
+
+export function isMessageReadableChannel(channel: Pick<DiscordChannel, 'type'>): boolean {
+  return isListableChannel(channel) && !NON_MESSAGE_CHANNEL_TYPES.has(channel.type)
+}
+
 export interface DiscordMessage {
   id: string
   channel_id: string

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

@@ -107,6 +107,7 @@ describe('KakaoTalkClient', () => {
     mockLogin.mockResolvedValue(structuredClone(DEFAULT_LOGIN_RESULT))
     mockGetChatLogs.mockResolvedValue({ body: { status: 0, chatLogs: [], eof: true } })
     mockGetChatInfo.mockResolvedValue({ body: { l: makeLong(99999) } })
+    mockSyncMessages.mockResolvedValue({ body: { status: 0, isOK: true, chatLogs: [] } })
   })
 
   afterEach(() => {
@@ -803,6 +804,34 @@ describe('KakaoTalkClient', () => {
   })
 
   describe('getMessages', () => {
+    it('falls back to SYNCMSG when MCHATLOGS succeeds with an empty result', async () => {
+      mockGetChatLogs.mockResolvedValueOnce({
+        body: { status: 0, chatLogs: [], eof: true },
+      })
+      mockGetChatInfo.mockResolvedValueOnce({
+        body: { status: 0, l: makeLong(10) },
+      })
+      mockSyncMessages.mockResolvedValueOnce({
+        body: {
+          status: 0,
+          isOK: true,
+          chatLogs: [
+            { logId: makeLong(10), chatId: 100, type: 1, authorId: 42, message: 'fallback', sendAt: 1700000001 },
+          ],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const messages = await client.getMessages('100')
+
+      expect(messages).toHaveLength(1)
+      expect(messages[0]?.message).toBe('fallback')
+      expect(mockGetChatInfo).toHaveBeenCalledTimes(1)
+      expect(mockSyncMessages).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
     it('returns formatted messages', async () => {
       mockGetChatLogs.mockResolvedValueOnce({
         body: {

package/src/platforms/kakaotalk/client.ts

@@ -850,6 +850,7 @@ export class KakaoTalkClient {
               (log) => longToString(log.chatId) === chatId,
             )
             if (batch.length === 0) {
+              if (allMessages.length === 0) break
               return formatMessages(allMessages, count, chatId, this.nameCache)
             }
 

package/src/platforms/slack/index.ts

@@ -3,6 +3,7 @@ export { SlackCredentialManager, CredentialManager } from './credential-manager'
 export { SlackListener } from './listener'
 export { loginWithQr } from './qr-http-login'
 export type { QrLoginOptions, QrSession } from './qr-http-login'
+export type { SlackConfirmationChallenge, SlackConfirmationCodeRequest } from './qr-confirmation'
 export { decodeSlackQr } from './qr-login'
 export type { SlackQrLogin } from './qr-login'
 export type {

package/src/platforms/slack/qr-confirmation.ts

@@ -0,0 +1,86 @@
+import type { SlackQrLogin } from './qr-login'
+
+export interface SlackConfirmationChallenge {
+  readonly email: string
+  readonly type: string | null
+}
+
+export type SlackConfirmationCodeRequest = (challenge: SlackConfirmationChallenge) => Promise<string>
+
+type SigninProps = {
+  readonly magicLogin: string
+  readonly emailAddress: string
+  readonly twoFactorType: string | null
+}
+
+export function parseConfirmationPage(html: string): SigninProps | null {
+  const match = html.match(/id="props_node"[^>]*\bdata-props="([^"]*)"/i)
+  const encoded = match?.[1]
+  if (!encoded) return null
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(decodeHtml(encoded))
+  } catch {
+    return null
+  }
+  if (!isRecord(parsed)) return null
+
+  const magicLogin = parsed.magicLogin
+  const emailAddress = parsed.emailAddress
+  if (typeof magicLogin !== 'string' || magicLogin === '') return null
+  if (typeof emailAddress !== 'string' || emailAddress === '') return null
+  return {
+    magicLogin,
+    emailAddress,
+    twoFactorType: typeof parsed.twoFactorType === 'string' ? parsed.twoFactorType : null,
+  }
+}
+
+export function buildConfirmationRequest(
+  login: SlackQrLogin,
+  finalUrl: string,
+  props: SigninProps,
+  code: string,
+): { readonly url: string; readonly body: string } | null {
+  const expected = expectedConfirmationPath(login)
+  if (!expected) return null
+  const url = new URL(finalUrl)
+  if (url.hostname !== `${login.workspace}.slack.com`) return null
+  if (url.pathname !== expected) return null
+
+  url.search = ''
+  url.searchParams.set('domain', login.workspace)
+  url.searchParams.set('domainLogin', '1')
+  url.searchParams.set('email', props.emailAddress)
+
+  return {
+    url: url.toString(),
+    body: new URLSearchParams({
+      '2fa_magiclogin': props.magicLogin,
+      remember: '0',
+      has_remember: 'false',
+      '2fa_code': code.trim(),
+      '2fa_action': 'submit_primary',
+    }).toString(),
+  }
+}
+
+export function expectedConfirmationPath(login: SlackQrLogin): string | null {
+  const qrSecret = new URL(login.url).pathname.split('/').at(-1)
+  if (!qrSecret || !qrSecret.startsWith('z-app-')) return null
+  return `/login/${qrSecret}`
+}
+
+function decodeHtml(value: string): string {
+  return value
+    .replaceAll('&quot;', '"')
+    .replaceAll('&#39;', "'")
+    .replaceAll('&lt;', '<')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&amp;', '&')
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}

package/src/platforms/slack/qr-cookie-jar.ts

@@ -0,0 +1,54 @@
+import { CookieJar } from 'tough-cookie'
+
+const BROWSER_USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36'
+
+const SESSION_COOKIE_NAME = 'd'
+const SESSION_COOKIE_PREFIX = 'xoxd-'
+
+export class SlackCookieJar {
+  readonly #jar = new CookieJar()
+
+  async fetch(doFetch: typeof fetch, url: string, init: RequestInit = {}): Promise<Response> {
+    const cookie = await this.#jar.getCookieString(url)
+    const response = await doFetch(url, {
+      ...init,
+      redirect: 'manual',
+      headers: {
+        'User-Agent': BROWSER_USER_AGENT,
+        Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.9',
+        ...init.headers,
+        ...(cookie ? { Cookie: cookie } : {}),
+      },
+    })
+    for (const setCookie of getSetCookies(response)) {
+      await this.#jar.setCookie(setCookie, url, { ignoreError: true })
+    }
+    return response
+  }
+
+  async sessionCookie(url: string): Promise<string | null> {
+    const cookies = await this.#jar.getCookies(url)
+    for (const cookie of cookies) {
+      if (cookie.key === SESSION_COOKIE_NAME && cookie.value.startsWith(SESSION_COOKIE_PREFIX)) {
+        return cookie.value
+      }
+    }
+    return null
+  }
+}
+
+export function setCookieNames(response: Response): readonly string[] {
+  return getSetCookies(response).flatMap((setCookie) => {
+    const name = setCookie.split('=')[0]?.trim()
+    return name ? [name] : []
+  })
+}
+
+function getSetCookies(response: Response): readonly string[] {
+  const withGetter = response.headers as Headers & { getSetCookie?: () => string[] }
+  if (typeof withGetter.getSetCookie === 'function') return withGetter.getSetCookie()
+  const single = response.headers.get('set-cookie')
+  return single ? [single] : []
+}