agent-messenger 2.36.0 → 2.37.0

package/src/platforms/kakaotalk/client.ts

@@ -8,6 +8,7 @@ import { getConfigDir } from '@/shared/utils/config-dir'
 import { warn } from '@/shared/utils/stderr'
 
 import { type AttachmentInput, type ResolvedAttachment, planAttachments } from './attachment-router'
+import { isOpenKakaoChatType } from './chat-classifier'
 import { detectImageDimensions } from './image-meta'
 import { sha1Hex } from './media-upload'
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
@@ -21,7 +22,9 @@ import {
   type KakaoLeaveChatResult,
   type KakaoMarkReadResult,
   type KakaoMember,
+  type KakaoMemberSnapshot,
   type KakaoMessage,
+  type KakaoMessagePage,
   type KakaoMultiPhotoExtra,
   type KakaoProfile,
   type KakaoReplyExtra,
@@ -184,7 +187,7 @@ function formatChat(chat: ChatData, title: string | null, nameCache: MemberNameC
 
   return {
     chat_id: chatId,
-    type: chat.t as number,
+    type: chat.t as KakaoChat['type'],
     display_name: displayName,
     title,
     active_members: chat.a as number,
@@ -207,10 +210,22 @@ interface ChannelMetaEntry {
   content?: string
 }
 
+interface ChannelInfoData {
+  chatId?: unknown
+  type?: unknown
+  activeMembersCount?: unknown
+  newMessageCount?: unknown
+  invalidNewMessageCount?: unknown
+  lastLogId?: unknown
+  lastSeenLogId?: unknown
+  lastChatLog?: Record<string, unknown> | null
+  displayMembers?: Array<Record<string, unknown>>
+  chatMetas?: ChannelMetaEntry[]
+  li?: unknown
+}
+
 interface ChannelInfoResponse {
-  chatInfo?: {
-    chatMetas?: ChannelMetaEntry[]
-  }
+  chatInfo?: ChannelInfoData
 }
 
 function extractTitle(body: Record<string, unknown>): string | null {
@@ -223,6 +238,69 @@ function extractTitle(body: Record<string, unknown>): string | null {
   return typeof content === 'string' && content.length > 0 ? content : null
 }
 
+function extractChannelInfo(body: Record<string, unknown>, expectedChatId: string): ChannelInfoData {
+  const info = (body as ChannelInfoResponse).chatInfo
+  if (!info || typeof info !== 'object') {
+    throw new Error('CHATINFO response missing chatInfo')
+  }
+  const responseChatId = longToString(info.chatId)
+  if (responseChatId !== expectedChatId) {
+    throw new Error('CHATINFO response chatId mismatch')
+  }
+  return info
+}
+
+function requiredNonNegativeInteger(value: unknown, field: string): number {
+  if (!Number.isInteger(value) || (value as number) < 0) {
+    throw new Error(`CHATINFO response invalid ${field}`)
+  }
+  return value as number
+}
+
+function requiredChatType(value: unknown): KakaoChat['type'] {
+  if (typeof value === 'string' && isOpenKakaoChatType(value)) {
+    return value
+  }
+  return requiredNonNegativeInteger(value, 'type')
+}
+
+function channelInfoToChatData(body: Record<string, unknown>, expectedChatId: string): ChatData {
+  const info = extractChannelInfo(body, expectedChatId)
+  const type = requiredChatType(info.type)
+  const activeMembers = requiredNonNegativeInteger(info.activeMembersCount, 'activeMembersCount')
+  const unreadCount =
+    info.invalidNewMessageCount === true ? 0 : requiredNonNegativeInteger(info.newMessageCount, 'newMessageCount')
+  const displayMembers = Array.isArray(info.displayMembers) ? info.displayMembers : []
+  const memberIds: unknown[] = []
+  const memberNames: string[] = []
+
+  for (const member of displayMembers) {
+    if (!member || typeof member !== 'object') continue
+    if (member.userId === undefined || typeof member.nickName !== 'string') continue
+    memberIds.push(member.userId)
+    memberNames.push(member.nickName)
+  }
+
+  return {
+    c: info.chatId,
+    t: type,
+    a: activeMembers,
+    n: unreadCount,
+    l: info.lastChatLog ?? null,
+    ll: info.lastLogId,
+    i: memberIds,
+    k: memberNames,
+    li: info.li,
+  }
+}
+
+function extractChannelMaxLogId(body: Record<string, unknown>, expectedChatId: string): Long {
+  const info = extractChannelInfo(body, expectedChatId)
+  const maxLogId = bsonToLong(info.lastLogId)
+  if (!maxLogId) throw new Error('CHATINFO response missing lastLogId')
+  return maxLogId
+}
+
 interface OpenLinkInfoResponse {
   ols?: Array<{ ln?: unknown }>
 }
@@ -234,10 +312,8 @@ function extractOpenLinkName(body: Record<string, unknown>): string | null {
   return typeof ln === 'string' && ln.length > 0 ? ln : null
 }
 
-const OPEN_CHAT_TYPES = new Set(['OM', 'OD'])
-
 function isOpenChat(chat: ChatData): boolean {
-  return typeof chat.t === 'string' && OPEN_CHAT_TYPES.has(chat.t)
+  return isOpenKakaoChatType(chat.t)
 }
 
 function getOpenLinkId(chat: ChatData): Long | null {
@@ -452,9 +528,29 @@ function formatMember(member: Record<string, unknown>): KakaoMember {
 }
 
 function memberIdKey(member: Record<string, unknown>): string | null {
-  if (member.userId === undefined || member.userId === null) return null
-  const key = longToString(member.userId)
-  return key === '0' ? null : key
+  const value = member.userId
+  if (typeof value === 'number') {
+    return Number.isSafeInteger(value) && value > 0 ? String(value) : null
+  }
+  if (!value || typeof value !== 'object' || !('low' in value) || !('high' in value)) {
+    return null
+  }
+  const { low, high } = value as {
+    low: unknown
+    high: unknown
+  }
+  if (
+    !Number.isInteger(low) ||
+    !Number.isInteger(high) ||
+    (low as number) < -0x80000000 ||
+    (low as number) > 0xffffffff ||
+    (high as number) < -0x80000000 ||
+    (high as number) > 0xffffffff
+  ) {
+    return null
+  }
+  const numeric = (BigInt((high as number) >>> 0) << 32n) | BigInt((low as number) >>> 0)
+  return numeric > 0n && numeric <= BigInt(Number.MAX_SAFE_INTEGER) ? numeric.toString() : null
 }
 
 function mergeMemberRecords(
@@ -484,19 +580,59 @@ function mergeMemberRecords(
   return merged
 }
 
-function extractChatInfoMembers(body: unknown): Array<Record<string, unknown>> {
-  if (!body || typeof body !== 'object') return []
-
-  const record = body as Record<string, unknown>
-  if (Array.isArray(record.m)) {
-    return record.m as Array<Record<string, unknown>>
+function exactMemberRecords(
+  value: unknown,
+  source: string,
+): {
+  records: Array<Record<string, unknown>>
+  ids: Set<string>
+} {
+  if (!Array.isArray(value)) {
+    throw new Error(`${source} member snapshot missing`)
+  }
+  const records: Array<Record<string, unknown>> = []
+  const ids = new Set<string>()
+  for (const raw of value) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+      throw new Error(`${source} member snapshot invalid`)
+    }
+    const record = raw as Record<string, unknown>
+    const id = memberIdKey(record)
+    if (!id || ids.has(id)) {
+      throw new Error(`${source} member snapshot invalid`)
+    }
+    ids.add(id)
+    records.push(record)
   }
+  return { records, ids }
+}
 
-  const chatInfo = record.chatInfo
-  if (!chatInfo || typeof chatInfo !== 'object') return []
+function sameIds(left: Set<string>, right: Set<string>): boolean {
+  return left.size === right.size && [...left].every((id) => right.has(id))
+}
 
-  const displayMembers = (chatInfo as Record<string, unknown>).displayMembers
-  return Array.isArray(displayMembers) ? (displayMembers as Array<Record<string, unknown>>) : []
+function subsetIds(subset: Set<string>, superset: Set<string>): boolean {
+  return [...subset].every((id) => superset.has(id))
+}
+
+function channelMemberView(
+  body: Record<string, unknown>,
+  expectedChatId: string,
+): {
+  activeMembers: number
+  records: Array<Record<string, unknown>>
+  ids: Set<string>
+} {
+  const info = extractChannelInfo(body, expectedChatId)
+  const activeMembers = requiredNonNegativeInteger(info.activeMembersCount, 'activeMembersCount')
+  const displayMembers = exactMemberRecords(info.displayMembers ?? [], 'CHATINFO')
+  if (displayMembers.records.length > activeMembers) {
+    throw new Error('CHATINFO member snapshot invalid')
+  }
+  return {
+    activeMembers,
+    ...displayMembers,
+  }
 }
 
 function formatMessages(
@@ -518,6 +654,50 @@ function formatMessages(
   }))
 }
 
+function formatForwardMessage(log: Record<string, unknown>, chatId: string, nameCache: MemberNameCache): KakaoMessage {
+  return {
+    log_id: longToString(log.logId),
+    type: log.type as number,
+    author_id: log.authorId as number,
+    author_name: nameCache.lookup(chatId, log.authorId as number),
+    message: log.message as string,
+    attachment: parseAttachmentJson(log.attachment),
+    sent_at: log.sendAt as number,
+  }
+}
+
+function buildMessagePage(
+  logs: Array<Record<string, unknown>>,
+  count: number,
+  cursor: Long,
+  protocolComplete: boolean,
+  chatId: string,
+  nameCache: MemberNameCache,
+): KakaoMessagePage {
+  const cursorValue = BigInt(cursor.toString())
+  const unique = new Map<string, Record<string, unknown>>()
+
+  for (const log of logs) {
+    const logId = longToString(log.logId)
+    if (BigInt(logId) <= cursorValue) continue
+    if (!unique.has(logId)) unique.set(logId, log)
+  }
+
+  const ordered = [...unique.entries()].sort(([left], [right]) => {
+    const a = BigInt(left)
+    const b = BigInt(right)
+    return a < b ? -1 : a > b ? 1 : 0
+  })
+  const selected = ordered.slice(0, count)
+  const nextCursor = selected.at(-1)?.[0] ?? null
+
+  return {
+    messages: selected.map(([, log]) => formatForwardMessage(log, chatId, nameCache)),
+    next_cursor: nextCursor,
+    complete: protocolComplete && ordered.length <= count,
+  }
+}
+
 function buildReplyExtra(target: KakaoReplyTarget): KakaoReplyExtra {
   return {
     attach_only: false,
@@ -810,6 +990,44 @@ export class KakaoTalkClient {
     })
   }
 
+  /**
+   * Fetch one chat directly by id via read-only CHATINFO.
+   *
+   * Unlike `getChats()`, this does not depend on the login-time snapshot or
+   * LCHATLIST pagination, so a room first observed from a live push can be
+   * resolved without interpreting protocol fields outside this SDK.
+   */
+  async getChat(chatId: string): Promise<KakaoChat> {
+    const parsedChatId = parseChatId(chatId)
+    const normalizedChatId = longToString(parsedChatId)
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const response = await session.getChannelInfo(parsedChatId)
+        assertLocoOk(response, 'CHATINFO')
+        const body = response.body as Record<string, unknown>
+        const chat = channelInfoToChatData(body, normalizedChatId)
+        this.nameCache.ingest([chat])
+
+        let title = extractTitle(body)
+        if (!title && isOpenChat(chat)) {
+          const linkId = getOpenLinkId(chat)
+          if (linkId) {
+            try {
+              const openLinkResponse = await session.getOpenLinkInfo([linkId])
+              title = extractOpenLinkName(openLinkResponse.body as Record<string, unknown>)
+            } catch {
+              title = null
+            }
+          }
+        }
+
+        return formatChat(chat, title, this.nameCache)
+      } catch (error) {
+        throw wrapError(error, 'get_chat_failed')
+      }
+    })
+  }
+
   /**
    * Resolve the user-set room title via CHATINFO. Returns null on any error
    * (network, malformed response, or no TITLE meta present). Designed to be
@@ -851,6 +1069,60 @@ export class KakaoTalkClient {
     }
   }
 
+  /**
+   * Fetch one forward-only, lossless history page after `from`.
+   *
+   * The page never keeps only the newest `count` entries. If the protocol
+   * returns more entries than requested, the oldest entries are returned and
+   * `complete` remains false so callers can continue from `next_cursor`.
+   */
+  async getMessagePage(chatId: string, options?: { count?: number; from?: string }): Promise<KakaoMessagePage> {
+    const count = options?.count ?? 100
+    if (!Number.isInteger(count) || count < 1 || count > 100) {
+      throw new KakaoTalkError('Message page count must be an integer between 1 and 100', 'invalid_message_page_count')
+    }
+    const parsedChatId = parseChatId(chatId)
+    const normalizedChatId = longToString(parsedChatId)
+    const cursor = options?.from ? parseLogId(options.from) : Long.fromNumber(0)
+
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const response = await session.getChatLogs([parsedChatId], [cursor])
+        assertLocoOk(response, 'MCHATLOGS')
+        const batch = ((response.body.chatLogs ?? []) as Array<Record<string, unknown>>).filter(
+          (log) => longToString(log.chatId) === normalizedChatId,
+        )
+
+        if (batch.length > 0) {
+          return buildMessagePage(batch, count, cursor, response.body.eof === true, normalizedChatId, this.nameCache)
+        }
+
+        // CHATINFO is read-only and supplies a fresh lastLogId even for rooms
+        // absent from the login snapshot. This avoids CHATONROOM, which can
+        // advance server-side unread state.
+        const chatInfoResponse = await session.getChannelInfo(parsedChatId)
+        assertLocoOk(chatInfoResponse, 'CHATINFO')
+        const maxLogId = extractChannelMaxLogId(chatInfoResponse.body as Record<string, unknown>, normalizedChatId)
+        if (maxLogId.lessThanOrEqual(cursor)) {
+          return { messages: [], next_cursor: null, complete: true }
+        }
+
+        const syncResponse = await session.syncMessages(parsedChatId, Math.min(count, 80), cursor, maxLogId)
+        assertLocoOk(syncResponse, 'SYNCMSG')
+        const syncBatch = ((syncResponse.body.chatLogs ?? []) as Array<Record<string, unknown>>).filter(
+          (log) => longToString(log.chatId) === normalizedChatId,
+        )
+        const maxReturned = findMaxLogId(syncBatch, 'logId')
+        const protocolComplete =
+          syncResponse.body.isOK === true || (maxReturned !== null && maxReturned.greaterThanOrEqual(maxLogId))
+
+        return buildMessagePage(syncBatch, count, cursor, protocolComplete, normalizedChatId, this.nameCache)
+      } catch (error) {
+        throw wrapError(error, 'get_message_page_failed')
+      }
+    })
+  }
+
   async getMessages(chatId: string, options?: { count?: number; from?: string }): Promise<KakaoMessage[]> {
     return this.executeWithReconnect(async ({ session, loginResult }) => {
       try {
@@ -949,30 +1221,60 @@ export class KakaoTalkClient {
     })
   }
 
-  async getMembers(chatId: string): Promise<KakaoMember[]> {
+  async getMemberSnapshot(chatId: string): Promise<KakaoMemberSnapshot> {
     const parsedChatId = parseChatId(chatId)
+    const normalizedChatId = longToString(parsedChatId)
     return this.executeWithReconnect(async ({ session }) => {
       try {
-        const response = await session.getAllMembers(parsedChatId)
-        assertLocoOk(response, 'GETMEM')
-        const members = (response.body.members ?? []) as Array<Record<string, unknown>>
-        let fallbackMembers: Array<Record<string, unknown>> = []
-        try {
-          // Some KakaoTalk rooms return only a subset from GETMEM even though
-          // CHATONROOM carries the full active member list in `m`.
-          const chatInfo = await session.getChatInfo(parsedChatId)
-          fallbackMembers = extractChatInfoMembers(chatInfo.body)
-        } catch {
-          fallbackMembers = []
+        const firstChatResponse = await session.getChannelInfo(parsedChatId)
+        assertLocoOk(firstChatResponse, 'CHATINFO')
+        const firstChat = channelMemberView(firstChatResponse.body as Record<string, unknown>, normalizedChatId)
+        const firstMemberResponse = await session.getAllMembers(parsedChatId)
+        assertLocoOk(firstMemberResponse, 'GETMEM')
+        const firstMembers = exactMemberRecords(firstMemberResponse.body.members ?? [], 'GETMEM')
+        const secondChatResponse = await session.getChannelInfo(parsedChatId)
+        assertLocoOk(secondChatResponse, 'CHATINFO')
+        const secondChat = channelMemberView(secondChatResponse.body as Record<string, unknown>, normalizedChatId)
+        const secondMemberResponse = await session.getAllMembers(parsedChatId)
+        assertLocoOk(secondMemberResponse, 'GETMEM')
+        const secondMembers = exactMemberRecords(secondMemberResponse.body.members ?? [], 'GETMEM')
+        if (
+          firstChat.activeMembers !== secondChat.activeMembers ||
+          firstMembers.records.length !== firstChat.activeMembers ||
+          secondMembers.records.length !== secondChat.activeMembers ||
+          !sameIds(firstChat.ids, secondChat.ids) ||
+          !sameIds(firstMembers.ids, secondMembers.ids) ||
+          !subsetIds(secondChat.ids, secondMembers.ids)
+        ) {
+          throw new Error('member_snapshot_changed_or_incomplete')
+        }
+        return {
+          chat_id: normalizedChatId,
+          active_members: secondChat.activeMembers,
+          members: mergeMemberRecords(secondMembers.records, secondChat.records).map(formatMember),
+          complete: true,
+          consistency_basis: 'stable_double_read_chatinfo_getmem',
         }
-
-        return mergeMemberRecords(members, fallbackMembers).map(formatMember)
       } catch (error) {
-        throw wrapError(error, 'get_members_failed')
+        throw wrapError(error, 'get_member_snapshot_failed')
       }
     })
   }
 
+  async getMembers(chatId: string): Promise<KakaoMember[]> {
+    try {
+      return (await this.getMemberSnapshot(chatId)).members
+    } catch (error) {
+      if (error instanceof KakaoTalkError && error.code === 'get_member_snapshot_failed') {
+        throw new KakaoTalkError(error.message, 'get_members_failed', {
+          cause: error,
+          serverStatus: error.serverStatus,
+        })
+      }
+      throw error
+    }
+  }
+
   async getMembersByIds(chatId: string, userIds: string[]): Promise<KakaoMember[]> {
     if (userIds.length === 0) return []
     const parsedChatId = parseChatId(chatId)

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

@@ -10,10 +10,12 @@ import {
   KakaoChatSchema,
   KakaoConfigSchema,
   KakaoLeaveChatResultSchema,
+  KakaoMessagePageSchema,
   KakaoMessageSchema,
   KakaoSendResultSchema,
   KakaoTalkClient,
   KakaoTalkError,
+  isOpenKakaoChatType,
   KakaoTalkListener,
   KakaoTalkPushMemberEventSchema,
   KakaoTalkPushMessageEventSchema,
@@ -51,6 +53,10 @@ it('KakaoMessageSchema is exported from barrel', () => {
   expect(typeof KakaoMessageSchema.parse).toBe('function')
 })
 
+it('KakaoMessagePageSchema is exported from barrel', () => {
+  expect(typeof KakaoMessagePageSchema.parse).toBe('function')
+})
+
 it('KakaoSendResultSchema is exported from barrel', () => {
   expect(typeof KakaoSendResultSchema.parse).toBe('function')
 })
@@ -83,6 +89,12 @@ it('classifyKakaoChat is exported from barrel', () => {
   expect(typeof classifyKakaoChat).toBe('function')
 })
 
+it('isOpenKakaoChatType is exported from barrel', () => {
+  expect(isOpenKakaoChatType('OM')).toBe(true)
+  expect(isOpenKakaoChatType(13)).toBe(true)
+  expect(isOpenKakaoChatType('UNKNOWN')).toBe(false)
+})
+
 it('KakaoLeaveChatResultSchema is exported from barrel', () => {
   expect(typeof KakaoLeaveChatResultSchema.parse).toBe('function')
 })

package/src/platforms/kakaotalk/index.ts

@@ -1,5 +1,5 @@
 export { KakaoTalkClient, KakaoTalkError } from './client'
-export { classifyKakaoChat } from './chat-classifier'
+export { classifyKakaoChat, isOpenKakaoChatType } from './chat-classifier'
 export type { KakaoChatKind } from './chat-classifier'
 export { KakaoCredentialManager, CredentialManager } from './credential-manager'
 export { KakaoTalkListener } from './listener'
@@ -9,6 +9,8 @@ export type {
   KakaoAuthErrorCode,
   KakaoAuthMethod,
   KakaoChat,
+  KakaoChatType,
+  KakaoOpenChatType,
   KakaoConfig,
   KakaoDeviceType,
   KakaoEmoticonKind,
@@ -18,7 +20,9 @@ export type {
   KakaoLoginResult,
   KakaoMarkReadResult,
   KakaoMember,
+  KakaoMemberSnapshot,
   KakaoMessage,
+  KakaoMessagePage,
   KakaoMultiPhotoExtra,
   KakaoPhotoExtra,
   KakaoProfile,
@@ -44,7 +48,9 @@ export {
   KakaoLeaveChatResultSchema,
   KakaoMarkReadResultSchema,
   KakaoMemberSchema,
+  KakaoMemberSnapshotSchema,
   KakaoMessageSchema,
+  KakaoMessagePageSchema,
   KakaoProfileSchema,
   KakaoSendResultSchema,
   KakaoTalkPushEmoticonEventSchema,

package/src/platforms/kakaotalk/types.ts

@@ -70,9 +70,12 @@ export const KAKAO_NEXT_ACTIONS: Record<string, { next_action: string; message:
   },
 }
 
+export type KakaoOpenChatType = 2 | 13 | 14 | 15 | 16 | 'OM' | 'OD'
+export type KakaoChatType = number | Extract<KakaoOpenChatType, string>
+
 export interface KakaoChat {
   chat_id: string
-  type: number
+  type: KakaoChatType
   display_name: string | null
   title: string | null
   active_members: number
@@ -95,6 +98,12 @@ export interface KakaoMessage {
   sent_at: number
 }
 
+export interface KakaoMessagePage {
+  messages: KakaoMessage[]
+  next_cursor: string | null
+  complete: boolean
+}
+
 export interface KakaoMember {
   user_id: string
   nickname: string
@@ -112,6 +121,14 @@ export interface KakaoMember {
   open_permission: number | null
 }
 
+export interface KakaoMemberSnapshot {
+  chat_id: string
+  active_members: number
+  members: KakaoMember[]
+  complete: true
+  consistency_basis: 'stable_double_read_chatinfo_getmem'
+}
+
 export interface KakaoSendResult {
   success: boolean
   status_code: number
@@ -222,7 +239,7 @@ export interface KakaoTypingResult {
 
 export const KakaoChatSchema = z.object({
   chat_id: z.string(),
-  type: z.number(),
+  type: z.union([z.number(), z.literal('OM'), z.literal('OD')]),
   display_name: z.string().nullable(),
   title: z.string().nullable(),
   active_members: z.number(),
@@ -247,6 +264,12 @@ export const KakaoMessageSchema = z.object({
   sent_at: z.number(),
 })
 
+export const KakaoMessagePageSchema = z.object({
+  messages: z.array(KakaoMessageSchema),
+  next_cursor: z.string().nullable(),
+  complete: z.boolean(),
+})
+
 export const KakaoMemberSchema = z.object({
   user_id: z.string(),
   nickname: z.string(),
@@ -261,6 +284,14 @@ export const KakaoMemberSchema = z.object({
   open_permission: z.number().nullable(),
 })
 
+export const KakaoMemberSnapshotSchema = z.object({
+  chat_id: z.string(),
+  active_members: z.number().int().nonnegative(),
+  members: z.array(KakaoMemberSchema),
+  complete: z.literal(true),
+  consistency_basis: z.literal('stable_double_read_chatinfo_getmem'),
+})
+
 export const KakaoSendResultSchema = z.object({
   success: z.boolean(),
   status_code: z.number(),

package/src/platforms/telegram/tdlib-node-test.ts

@@ -0,0 +1,19 @@
+import { TdjsonBinding } from './tdlib'
+
+function fail(message: string): never {
+  console.error(message)
+  process.exit(1)
+}
+
+if (typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined') {
+  fail('Expected Node.js runtime, but Bun was detected')
+}
+
+const binding = await TdjsonBinding.create()
+const version = binding.execute({ '@type': 'getOption', name: 'version' })
+
+if (version?.['@type'] !== 'optionValueString' || typeof version.value !== 'string') {
+  fail(`Expected TDLib version, got: ${JSON.stringify(version)}`)
+}
+
+console.log('ok')

package/src/platforms/telegram/tdlib-node.test.ts

@@ -0,0 +1,11 @@
+import { expect, it } from 'bun:test'
+import { execSync } from 'node:child_process'
+
+it('loads TDLib in Node.js', () => {
+  const result = execSync('bun tsx src/platforms/telegram/tdlib-node-test.ts', {
+    cwd: process.cwd(),
+    encoding: 'utf-8',
+  })
+
+  expect(result.trim()).toBe('ok')
+})

package/src/platforms/telegram/tdlib.ts

@@ -7,6 +7,10 @@ interface TdjsonSymbols {
   td_execute: (request: string) => string | null
 }
 
+function unwrapDefaultExport<T>(moduleNamespace: T): T {
+  return (moduleNamespace as T & { default?: T }).default ?? moduleNamespace
+}
+
 let cachedKoffi: typeof import('koffi') | undefined
 
 async function getKoffi(): Promise<typeof import('koffi')> {
@@ -15,7 +19,7 @@ async function getKoffi(): Promise<typeof import('koffi')> {
   }
 
   try {
-    cachedKoffi = await import('koffi')
+    cachedKoffi = unwrapDefaultExport(await import('koffi'))
     return cachedKoffi
   } catch {
     throw new Error('koffi is required for Telegram support. Install it with: bun add koffi prebuilt-tdlib')
@@ -36,7 +40,7 @@ function getLibrarySuffix(): string {
 
 async function getPrebuiltTdjsonPath(): Promise<string | undefined> {
   try {
-    const mod = (await import('prebuilt-tdlib')) as { getTdjson?: () => string }
+    const mod = unwrapDefaultExport((await import('prebuilt-tdlib')) as { getTdjson?: () => string })
     const tdjson = mod.getTdjson?.()
     return typeof tdjson === 'string' && tdjson.length > 0 ? tdjson : undefined
   } catch {