teh-bot 1.0.4 → 1.0.6

package/{index.js → dist/index.cjs}

@@ -65,7 +65,7 @@ class TelegramBot extends EventEmitter {
         method: "POST",
         headers: {
           ...headers,
-          "User-Agent": "TehBot/1.0.0 (Modern; High-Performance)",
+          "User-Agent": "TehBot/1.0.5 (Modern; High-Performance)",
         },
         timeout: this.options.requestTimeout,
       }
@@ -100,8 +100,32 @@ class TelegramBot extends EventEmitter {
     })
   }
 
+  async getMe() {
+    return this.request("getMe")
+  }
+
+  async getUpdates(params = {}) {
+    return this.request("getUpdates", {
+      offset: this.offset,
+      timeout: this.options.pollingTimeout,
+      allowed_updates: this.options.allowedUpdates,
+      ...params,
+    })
+  }
+
+  async setWebhook(url, params = {}) {
+    return this.request("setWebhook", { url, ...params })
+  }
+
+  async deleteWebhook(params = {}) {
+    return this.request("deleteWebhook", params)
+  }
+
+  async getWebhookInfo() {
+    return this.request("getWebhookInfo")
+  }
+
   async sendMessage(chatId, content, options = {}) {
-    // content can be string (text) or object { image: ..., caption: ... }
     if (typeof content === "string") {
       return this.request("sendMessage", { chat_id: chatId, text: content, ...options })
     }
@@ -607,7 +631,6 @@ class TelegramBot extends EventEmitter {
   _createContext(update) {
     const message = update.message || update.edited_message || update.channel_post || update.callback_query?.message
 
-    // Fallback logic for chat extraction from various update types
     const chat =
       update.message?.chat ||
       update.callback_query?.message?.chat ||
@@ -642,7 +665,6 @@ class TelegramBot extends EventEmitter {
       chatMember: update.chat_member,
     }
 
-    // Baileys-style simplified response
     ctx.send = (content, opts) => {
       const chatId =
         ctx.chat?.id ||
@@ -652,7 +674,7 @@ class TelegramBot extends EventEmitter {
         from?.id
 
       if (!chatId) {
-        console.error("[v0] Context update without valid chatId destination:", JSON.stringify(update))
+        console.error("[Teh] Context update without valid chatId destination:", JSON.stringify(update))
         throw new Error("[Teh] Cannot send message: chat_id could not be resolved from this update context")
       }
       return this.sendMessage(chatId, content, opts)
@@ -669,13 +691,11 @@ class TelegramBot extends EventEmitter {
       })
     }
 
-    // Context helpers for media
     ctx.replyWithPhoto = (photo, opts) => ctx.send({ image: photo, ...opts })
     ctx.replyWithVideo = (video, opts) => ctx.send({ video, ...opts })
     ctx.replyWithAudio = (audio, opts) => ctx.send({ audio, ...opts })
     ctx.replyWithDocument = (doc, opts) => ctx.send({ document: doc, ...opts })
 
-    // Helper methods for callback queries
     ctx.answerCallbackQuery = (options = {}) => {
       if (!ctx.callbackQuery?.id) return Promise.resolve(false)
       return this.answerCallbackQuery(ctx.callbackQuery.id, options)
@@ -683,7 +703,6 @@ class TelegramBot extends EventEmitter {
 
     ctx.editMessageText = (text, options = {}) => {
       if (!ctx.callbackQuery?.message) {
-        // If it's an inline message (no message object), we need the inline_message_id
         if (ctx.callbackQuery?.inline_message_id) {
           return this.editMessageText(text, {
             inline_message_id: ctx.callbackQuery.inline_message_id,
@@ -741,163 +760,86 @@ class TelegramBot extends EventEmitter {
             stream.push(`Content-Type: ${contentType}${nl}${nl}`)
 
             if (fileData instanceof Stream) {
-              for await (const chunk of fileData) {
-                const canPush = stream.push(chunk)
-                if (!canPush) {
-                  await new Promise((resolve) => stream.once("drain", resolve))
-                }
-              }
+              fileData.pipe(stream, { end: false })
+              await new Promise((resolve, reject) => {
+                fileData.on("end", resolve)
+                fileData.on("error", reject)
+              })
             } else {
               stream.push(fileData)
             }
           } else {
             stream.push(`Content-Disposition: form-data; name="${key}"${nl}${nl}`)
-            stream.push(typeof value === "object" ? JSON.stringify(value) : String(value))
+            stream.push(String(value))
           }
-          stream.push(nl)
+          stream.push(`${nl}`)
         }
         stream.push(`--${boundary}--${nl}`)
-      } catch (err) {
-        console.error("[v0] Error building multipart stream:", err)
-      } finally {
         stream.push(null)
+      } catch (err) {
+        stream.destroy(err)
       }
     })()
-
     return stream
   }
 
-  async _prepareFile(source, type) {
-    const defaultMime = this._getMime(type) || "image/jpeg"
-
-    if (source instanceof Stream) return { data: source, contentType: defaultMime }
-    if (Buffer.isBuffer(source)) return { data: source, contentType: defaultMime }
-
-    if (typeof source === "string") {
-      if (source.startsWith("http")) {
-        return new Promise((resolve, reject) => {
-          https
-            .get(source, (res) => {
-              const filename = basename(new URL(source).pathname) || `file_${Date.now()}.jpg`
-              const contentType = res.headers["content-type"] || defaultMime
-              resolve({
-                data: res,
-                filename: filename,
-                contentType: contentType,
-              })
-            })
-            .on("error", reject)
-        })
-      }
-
-      // Local file
-      const filename = basename(source)
-      return {
-        data: createReadStream(source),
-        filename: filename,
-        contentType: this._getMime(extname(filename)) || defaultMime,
-      }
-    }
-    return source
-  }
-
-  _getMime(extOrType) {
-    const mimes = {
-      photo: "image/jpeg",
-      image: "image/jpeg",
-      video: "video/mp4",
-      audio: "audio/mpeg",
-      document: "application/octet-stream",
+  _getMime(ext) {
+    const mimeTypes = {
       ".jpg": "image/jpeg",
       ".jpeg": "image/jpeg",
       ".png": "image/png",
       ".gif": "image/gif",
       ".mp4": "video/mp4",
+      ".avi": "video/x-msvideo",
+      ".webm": "video/webm",
       ".mp3": "audio/mpeg",
+      ".ogg": "audio/ogg",
+      ".wav": "audio/wav",
       ".pdf": "application/pdf",
-      ".zip": "application/zip",
+      ".doc": "application/msword",
+      ".txt": "text/plain",
     }
-    const key = extOrType?.toLowerCase()
-    return mimes[key] || (key?.startsWith(".") ? "application/octet-stream" : mimes.photo)
+    return mimeTypes[ext.toLowerCase()] || "application/octet-stream"
   }
 
-  _flattenOptions(options) {
-    const flat = {}
-    for (const [key, value] of Object.entries(options)) {
-      if (typeof value === "object" && value !== null) {
-        flat[key] = JSON.stringify(value)
-      } else {
-        flat[key] = value
+  async _prepareFile(source, type) {
+    if (typeof source === "string") {
+      if (source.startsWith("http://") || source.startsWith("https://")) {
+        return source
       }
-    }
-    return flat
-  }
 
-  _formatError(resp) {
-    const err = new Error(resp.description || "Unknown Telegram Error")
-    err.code = resp.error_code
-    err.parameters = resp.parameters
-    err.response = resp
-    err.name = "TelegramAPIError"
-    return err
-  }
-
-  async deleteWebhook(options = {}) {
-    return this.request("deleteWebhook", options)
-  }
-
-  async setWebhook(url, options = {}) {
-    return this.request("setWebhook", {
-      url,
-      ...options,
-    })
-  }
-
-  async getWebhookInfo() {
-    return this.request("getWebhookInfo")
-  }
-
-  async getMe() {
-    return this.request("getMe")
-  }
-
-  async _sendFile(method, chatId, source, type, options = {}) {
-    const formData = {
-      chat_id: chatId,
-      [type]: await this._prepareFile(source, type),
-      ...this._flattenOptions(options),
+      try {
+        const stat = statSync(source)
+        if (stat.isFile()) {
+          return {
+            data: createReadStream(source),
+            filename: basename(source),
+            contentType: this._getMime(extname(source)),
+          }
+        }
+      } catch (e) {
+        return source
+      }
     }
-    return this.request(method, {}, formData)
-  }
-
-  async setMyCommands(commands, options = {}) {
-    return this.request("setMyCommands", { commands, ...options })
-  }
 
-  async getMyCommands(options = {}) {
-    return this.request("getMyCommands", options)
-  }
-
-  async setChatMenuButton(options = {}) {
-    return this.request("setChatMenuButton", options)
-  }
-
-  async getChatMenuButton(options = {}) {
-    return this.request("getChatMenuButton", options)
-  }
+    if (Buffer.isBuffer(source) || source instanceof Stream) {
+      return {
+        data: source,
+        filename: `file_${Date.now()}.jpg`,
+        contentType: "image/jpeg",
+      }
+    }
 
-  async getUserProfilePhotos(userId, options = {}) {
-    return this.request("getUserProfilePhotos", { user_id: userId, ...options })
+    return source
   }
 
-  async createChatInviteLink(chatId, options = {}) {
-    return this.request("createChatInviteLink", { chat_id: chatId, ...options })
+  _formatError(response) {
+    const error = new Error(response.description || "Telegram API Error")
+    error.response = response
+    error.errorCode = response.error_code
+    return error
   }
 
-  async revokeChatInviteLink(chatId, inviteLink) {
-    return this.request("revokeChatInviteLink", { chat_id: chatId, invite_link: inviteLink })
-  }
-  
   static InlineKeyboard() {
     return new InlineKeyboardBuilder()
   }
@@ -906,25 +848,22 @@ class TelegramBot extends EventEmitter {
     return new ReplyKeyboardBuilder()
   }
 
-  static RemoveKeyboard(selective = false) {
-    return { remove_keyboard: true, selective }
+  static RemoveKeyboard() {
+    return { remove_keyboard: true }
   }
 
-  static ForceReply(selective = false, placeholder = "") {
-    const obj = { force_reply: true, selective }
-    if (placeholder) obj.input_field_placeholder = placeholder
-    return obj
+  static ForceReply() {
+    return { force_reply: true }
   }
 }
 
 class InlineKeyboardBuilder {
   constructor() {
-    this.keyboard = []
-    this.currentRow = []
+    this.keyboard = [[]]
   }
 
   text(text, callbackData) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       callback_data: callbackData,
     })
@@ -932,7 +871,7 @@ class InlineKeyboardBuilder {
   }
 
   url(text, url) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       url,
     })
@@ -940,7 +879,7 @@ class InlineKeyboardBuilder {
   }
 
   login(text, loginUrl) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       login_url: loginUrl,
     })
@@ -948,7 +887,7 @@ class InlineKeyboardBuilder {
   }
 
   switchInline(text, query = "") {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       switch_inline_query: query,
     })
@@ -956,7 +895,7 @@ class InlineKeyboardBuilder {
   }
 
   switchInlineCurrent(text, query = "") {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       switch_inline_query_current_chat: query,
     })
@@ -964,7 +903,7 @@ class InlineKeyboardBuilder {
   }
 
   game(text) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       callback_game: {},
     })
@@ -972,7 +911,7 @@ class InlineKeyboardBuilder {
   }
 
   pay(text) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       pay: true,
     })
@@ -980,35 +919,28 @@ class InlineKeyboardBuilder {
   }
 
   row() {
-    if (this.currentRow.length > 0) {
-      this.keyboard.push([...this.currentRow])
-      this.currentRow = []
-    }
+    this.keyboard.push([])
     return this
   }
 
   build() {
-    this.row()
-    return {
-      inline_keyboard: this.keyboard,
-    }
+    return { inline_keyboard: this.keyboard }
   }
 }
 
 class ReplyKeyboardBuilder {
   constructor() {
-    this.keyboard = []
-    this.currentRow = []
+    this.keyboard = [[]]
     this.options = {}
   }
 
   text(text) {
-    this.currentRow.push({ text })
+    this.keyboard[this.keyboard.length - 1].push({ text })
     return this
   }
 
   requestContact(text) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       request_contact: true,
     })
@@ -1016,15 +948,15 @@ class ReplyKeyboardBuilder {
   }
 
   requestLocation(text) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       request_location: true,
     })
     return this
   }
 
-  requestPoll(text, type) {
-    this.currentRow.push({
+  requestPoll(text, type = "quiz") {
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       request_poll: { type },
     })
@@ -1032,10 +964,7 @@ class ReplyKeyboardBuilder {
   }
 
   row() {
-    if (this.currentRow.length > 0) {
-      this.keyboard.push([...this.currentRow])
-      this.currentRow = []
-    }
+    this.keyboard.push([])
     return this
   }
 
@@ -1060,7 +989,6 @@ class ReplyKeyboardBuilder {
   }
 
   build() {
-    this.row()
     return {
       keyboard: this.keyboard,
       ...this.options,