teh-bot 1.0.2 → 1.0.4

package/index.js

@@ -86,8 +86,14 @@ 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()
       }
@@ -384,6 +390,11 @@ class TelegramBot extends EventEmitter {
   }
 
   command(cmd, handler) {
+    if (handler === undefined) {
+      const commandName = typeof cmd === "string" ? (cmd.startsWith("/") ? cmd : `/${cmd}`) : ""
+      return this.commands.get(commandName)
+    }
+
     if (typeof handler !== "function") {
       throw new Error("Command handler must be a function")
     }
@@ -597,16 +608,17 @@ class TelegramBot extends EventEmitter {
     const message = update.message || update.edited_message || update.channel_post || update.callback_query?.message
 
     // Fallback logic for chat extraction from various update types
-    let chat =
-      message?.chat || update.my_chat_member?.chat || update.chat_member?.chat || update.chat_join_request?.chat
-
-    // Explicit extraction for callback_query which might not have a message (inline buttons)
-    if (!chat && update.callback_query) {
-      chat = update.callback_query.message?.chat
-    }
+    const chat =
+      update.message?.chat ||
+      update.callback_query?.message?.chat ||
+      update.my_chat_member?.chat ||
+      update.chat_member?.chat ||
+      update.chat_join_request?.chat ||
+      update.edited_message?.chat ||
+      update.channel_post?.chat
 
     const from =
-      message?.from ||
+      update.message?.from ||
       update.callback_query?.from ||
       update.inline_query?.from ||
       update.chosen_inline_result?.from ||
@@ -632,18 +644,24 @@ class TelegramBot extends EventEmitter {
 
     // Baileys-style simplified response
     ctx.send = (content, opts) => {
-      const chatId = ctx.chat?.id || update.callback_query?.from?.id || update.inline_query?.from?.id
+      const chatId =
+        ctx.chat?.id ||
+        update.callback_query?.from?.id ||
+        update.inline_query?.from?.id ||
+        update.message?.from?.id ||
+        from?.id
+
       if (!chatId) {
-        console.error("[v0] Context update without chat_id:", JSON.stringify(update))
-        throw new Error("[Teh] Cannot send message: chat_id is not available in this context")
+        console.error("[v0] 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)
     }
 
     ctx.reply = (text, opts) => {
-      const chatId = ctx.chat?.id || update.callback_query?.from?.id
+      const chatId = ctx.chat?.id || update.callback_query?.from?.id || from?.id
       if (!chatId) {
-        throw new Error("[Teh] Cannot reply: chat_id is not available in this context")
+        throw new Error("[Teh] Cannot reply: chat_id could not be resolved from this update context")
       }
       return this.sendMessage(chatId, text, {
         reply_to_message_id: ctx.message?.message_id,
@@ -704,54 +722,68 @@ 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) {
+              for await (const chunk of fileData) {
+                const canPush = stream.push(chunk)
+                if (!canPush) {
+                  await new Promise((resolve) => stream.once("drain", resolve))
+                }
+              }
+            } else {
+              stream.push(fileData)
+            }
           } else {
-            stream.push(value.data)
+            stream.push(`Content-Disposition: form-data; name="${key}"${nl}${nl}`)
+            stream.push(typeof value === "object" ? JSON.stringify(value) : 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}`)
+      } catch (err) {
+        console.error("[v0] Error building multipart stream:", err)
+      } finally {
+        stream.push(null)
       }
-      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) }
+    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")) {
-        // Fetch remote URL and return as stream
         return new Promise((resolve, reject) => {
-          const client = source.startsWith("https") ? https : http
-          client
+          https
             .get(source, (res) => {
-              if (res.statusCode !== 200) {
-                return reject(new Error(`Failed to fetch remote file: ${res.statusCode}`))
-              }
+              const filename = basename(new URL(source).pathname) || `file_${Date.now()}.jpg`
+              const contentType = res.headers["content-type"] || defaultMime
               resolve({
                 data: res,
-                filename: basename(new URL(source).pathname) || `file_${Date.now()}`,
-                contentType: res.headers["content-type"] || this._getMime(type),
+                filename: filename,
+                contentType: contentType,
               })
             })
             .on("error", reject)
@@ -759,25 +791,34 @@ class TelegramBot extends EventEmitter {
       }
 
       // Local file
+      const filename = basename(source)
       return {
         data: createReadStream(source),
-        filename: basename(source),
-        contentType: this._getMime(extname(source)),
+        filename: filename,
+        contentType: this._getMime(extname(filename)) || defaultMime,
       }
     }
     return source
   }
 
-  _getMime(ext) {
+  _getMime(extOrType) {
     const mimes = {
       photo: "image/jpeg",
+      image: "image/jpeg",
       video: "video/mp4",
       audio: "audio/mpeg",
+      document: "application/octet-stream",
       ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
       ".png": "image/png",
+      ".gif": "image/gif",
       ".mp4": "video/mp4",
+      ".mp3": "audio/mpeg",
+      ".pdf": "application/pdf",
+      ".zip": "application/zip",
     }
-    return mimes[ext] || "application/octet-stream"
+    const key = extOrType?.toLowerCase()
+    return mimes[key] || (key?.startsWith(".") ? "application/octet-stream" : mimes.photo)
   }
 
   _flattenOptions(options) {
@@ -816,6 +857,47 @@ class TelegramBot extends EventEmitter {
     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),
+    }
+    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)
+  }
+
+  async getUserProfilePhotos(userId, options = {}) {
+    return this.request("getUserProfilePhotos", { user_id: userId, ...options })
+  }
+
+  async createChatInviteLink(chatId, options = {}) {
+    return this.request("createChatInviteLink", { chat_id: chatId, ...options })
+  }
+
+  async revokeChatInviteLink(chatId, inviteLink) {
+    return this.request("revokeChatInviteLink", { chat_id: chatId, invite_link: inviteLink })
+  }
+  
   static InlineKeyboard() {
     return new InlineKeyboardBuilder()
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teh-bot",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Lightweight, high-performance Telegram Bot API module with zero dependencies",
   "keywords": [
     "telegram",