teh-bot 1.0.3 → 1.0.5

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,
       }
@@ -86,16 +86,46 @@ class TelegramBot extends EventEmitter {
       })
 
       req.on("error", reject)
-      if (body instanceof Stream) body.pipe(req)
-      else {
+      if (body instanceof Stream) {
+        body.pipe(req)
+        body.on("end", () => req.end())
+        body.on("error", (err) => {
+          req.destroy()
+          reject(err)
+        })
+      } else {
         req.write(body)
         req.end()
       }
     })
   }
 
+  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 })
     }
@@ -601,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 ||
@@ -636,7 +665,6 @@ class TelegramBot extends EventEmitter {
       chatMember: update.chat_member,
     }
 
-    // Baileys-style simplified response
     ctx.send = (content, opts) => {
       const chatId =
         ctx.chat?.id ||
@@ -646,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)
@@ -663,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)
@@ -677,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,
@@ -716,116 +741,103 @@ class TelegramBot extends EventEmitter {
   }
 
   _buildMultipartStream(formData, boundary) {
-    const stream = new Readable({ read() {} })
+    const stream = new Readable({
+      read() {},
+    })
     const nl = "\r\n"
     ;(async () => {
-      for (const [key, value] of Object.entries(formData)) {
-        if (value === undefined || value === null) continue
-
-        stream.push(`--${boundary}${nl}`)
-        if (value && typeof value === "object" && value.data) {
-          const filename = value.filename || `file_${Date.now()}`
-          stream.push(`Content-Disposition: form-data; name="${key}"; filename="${filename}"${nl}`)
-          stream.push(`Content-Type: ${value.contentType || "application/octet-stream"}${nl}${nl}`)
-
-          if (value.data instanceof Stream) {
-            for await (const chunk of value.data) stream.push(chunk)
+      try {
+        for (const [key, value] of Object.entries(formData)) {
+          if (value === undefined || value === null) continue
+
+          stream.push(`--${boundary}${nl}`)
+          if (value && typeof value === "object" && (value.data || value instanceof Stream || Buffer.isBuffer(value))) {
+            const fileData = value.data || value
+            const filename = value.filename || `file_${Date.now()}.jpg`
+            const contentType = value.contentType || this._getMime(extname(filename)) || "image/jpeg"
+
+            stream.push(`Content-Disposition: form-data; name="${key}"; filename="${filename}"${nl}`)
+            stream.push(`Content-Type: ${contentType}${nl}${nl}`)
+
+            if (fileData instanceof Stream) {
+              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(value.data)
+            stream.push(`Content-Disposition: form-data; name="${key}"${nl}${nl}`)
+            stream.push(String(value))
           }
-        } else {
-          stream.push(`Content-Disposition: form-data; name="${key}"${nl}${nl}`)
-          stream.push(typeof value === "object" ? JSON.stringify(value) : String(value))
+          stream.push(`${nl}`)
         }
-        stream.push(nl)
+        stream.push(`--${boundary}--${nl}`)
+        stream.push(null)
+      } catch (err) {
+        stream.destroy(err)
       }
-      stream.push(`--${boundary}--${nl}`)
-      stream.push(null)
     })()
-
     return stream
   }
 
-  async _prepareFile(source, type) {
-    if (source instanceof Stream) return { data: source, contentType: this._getMime(type) }
-    if (Buffer.isBuffer(source)) return { data: source, contentType: this._getMime(type) }
-
-    if (typeof source === "string") {
-      if (source.startsWith("http")) {
-        // Fetch remote URL and return as stream
-        return new Promise((resolve, reject) => {
-          const client = source.startsWith("https") ? https : http
-          client
-            .get(source, (res) => {
-              if (res.statusCode !== 200) {
-                return reject(new Error(`Failed to fetch remote file: ${res.statusCode}`))
-              }
-              resolve({
-                data: res,
-                filename: basename(new URL(source).pathname) || `file_${Date.now()}`,
-                contentType: res.headers["content-type"] || this._getMime(type),
-              })
-            })
-            .on("error", reject)
-        })
-      }
-
-      // Local file
-      return {
-        data: createReadStream(source),
-        filename: basename(source),
-        contentType: this._getMime(extname(source)),
-      }
-    }
-    return source
-  }
-
   _getMime(ext) {
-    const mimes = {
-      photo: "image/jpeg",
-      video: "video/mp4",
-      audio: "audio/mpeg",
+    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",
+      ".doc": "application/msword",
+      ".txt": "text/plain",
     }
-    return mimes[ext] || "application/octet-stream"
+    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
-  }
+      try {
+        const stat = statSync(source)
+        if (stat.isFile()) {
+          return {
+            data: createReadStream(source),
+            filename: basename(source),
+            contentType: this._getMime(extname(source)),
+          }
+        }
+      } catch (e) {
+        return source
+      }
+    }
 
-  async deleteWebhook(options = {}) {
-    return this.request("deleteWebhook", options)
-  }
+    if (Buffer.isBuffer(source) || source instanceof Stream) {
+      return {
+        data: source,
+        filename: `file_${Date.now()}.jpg`,
+        contentType: "image/jpeg",
+      }
+    }
 
-  async setWebhook(url, options = {}) {
-    return this.request("setWebhook", {
-      url,
-      ...options,
-    })
+    return source
   }
 
-  async getWebhookInfo() {
-    return this.request("getWebhookInfo")
+  _formatError(response) {
+    const error = new Error(response.description || "Telegram API Error")
+    error.response = response
+    error.errorCode = response.error_code
+    return error
   }
 
   static InlineKeyboard() {
@@ -836,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,
     })
@@ -862,7 +871,7 @@ class InlineKeyboardBuilder {
   }
 
   url(text, url) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       url,
     })
@@ -870,7 +879,7 @@ class InlineKeyboardBuilder {
   }
 
   login(text, loginUrl) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       login_url: loginUrl,
     })
@@ -878,7 +887,7 @@ class InlineKeyboardBuilder {
   }
 
   switchInline(text, query = "") {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       switch_inline_query: query,
     })
@@ -886,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,
     })
@@ -894,7 +903,7 @@ class InlineKeyboardBuilder {
   }
 
   game(text) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       callback_game: {},
     })
@@ -902,7 +911,7 @@ class InlineKeyboardBuilder {
   }
 
   pay(text) {
-    this.currentRow.push({
+    this.keyboard[this.keyboard.length - 1].push({
       text,
       pay: true,
     })
@@ -910,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,
     })
@@ -946,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 },
     })
@@ -962,10 +964,7 @@ class ReplyKeyboardBuilder {
   }
 
   row() {
-    if (this.currentRow.length > 0) {
-      this.keyboard.push([...this.currentRow])
-      this.currentRow = []
-    }
+    this.keyboard.push([])
     return this
   }
 
@@ -990,7 +989,6 @@ class ReplyKeyboardBuilder {
   }
 
   build() {
-    this.row()
     return {
       keyboard: this.keyboard,
       ...this.options,