agent-messenger 2.32.0 → 2.32.1

package/src/platforms/discord/commands/snapshot.ts

@@ -6,6 +6,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
+import { isListableChannel, isMessageReadableChannel } from '../types'
 import type { DiscordChannel } from '../types'
 
 export async function snapshotAction(options: {
@@ -41,8 +42,9 @@ export async function snapshotAction(options: {
 
       if (!options.usersOnly) {
         const channels = await client.listChannels(serverId)
+        const listableChannels = channels.filter(isListableChannel)
 
-        snapshot.channels = channels.map((ch) => ({
+        snapshot.channels = listableChannels.map((ch) => ({
           id: ch.id,
           name: ch.name,
           type: ch.type,
@@ -50,11 +52,10 @@ export async function snapshotAction(options: {
         }))
 
         if (!options.channelsOnly) {
-          const isTextChannel = (ch: DiscordChannel) => ch.type === 0 || ch.type === 5
-          const textChannels = channels.filter(isTextChannel)
+          const readableChannels = listableChannels.filter(isMessageReadableChannel)
 
           const channelMessages = await parallelMap(
-            textChannels,
+            readableChannels,
             async (channel: DiscordChannel) => {
               const messages = await client.getMessages(channel.id, messageLimit)
               return messages.map((msg) => ({
@@ -88,8 +89,8 @@ export async function snapshotAction(options: {
     } else {
       if (!options.usersOnly) {
         const channels = await client.listChannels(serverId)
-        const textChannels = channels.filter((ch: DiscordChannel) => ch.type === 0 || ch.type === 5)
-        snapshot.channels = textChannels.map((ch) => ({ id: ch.id, name: ch.name }))
+        const listableChannels = channels.filter(isListableChannel)
+        snapshot.channels = listableChannels.map((ch) => ({ id: ch.id, name: ch.name }))
       }
 
       snapshot.hint =

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/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] : []
+}