xzcgram 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xzcgram",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A Telegraf-style command/hears router built on top of GramJS (telegram)",
   "main": "index.js",
   "homepage": "https://www.npmjs.com/package/xzcgram",

package/src/bot.js

@@ -1,9 +1,26 @@
 const { NewMessage } = require("telegram/events");
-const { NewCallbackQuery } = require("telegram/events/NewCallbackQuery");
 const { Context } = require("./context");
 
+// CallbackQuery (inline button presses) — imported defensively since its
+// export path has moved between "telegram" package versions. If it can't
+// be found, bot.action() handlers simply won't fire, but everything else
+// (commands, hears, media, etc.) keeps working.
+let CallbackQuery = null;
+try {
+  ({ CallbackQuery } = require("telegram/events"));
+} catch (err) {
+  /* ignore, try next path */
+}
+if (!CallbackQuery) {
+  try {
+    ({ CallbackQuery } = require("telegram/events/CallbackQuery"));
+  } catch (err) {
+    /* ignore, handled below */
+  }
+}
+
 /**
- * CallbackContext wraps a GramJS NewCallbackQuery event, exposed to
+ * CallbackContext wraps a GramJS CallbackQuery event, exposed to
  * handlers registered via bot.action(...).
  */
 class CallbackContext {
@@ -17,6 +34,20 @@ class CallbackContext {
     this.data = event.data ? event.data.toString("utf-8") : "";
   }
 
+  /**
+   * Resolves the correct peer to send to/act on. See Context._peer() for
+   * why this is needed instead of a raw numeric chatId.
+   */
+  async _peer() {
+    try {
+      const inputChat = await this.event.getInputChat();
+      if (inputChat) return inputChat;
+    } catch (err) {
+      // fall through to raw chatId below
+    }
+    return this.chatId;
+  }
+
   /** Answer the callback query (e.g. show a small toast/alert to the user). */
   answer(text = "", opts = {}) {
     return this.event.answer({ message: text, ...opts });
@@ -28,8 +59,9 @@ class CallbackContext {
   }
 
   /** Send a new message in the same chat as the callback query. */
-  reply(text, opts = {}) {
-    return this.client.sendMessage(this.chatId, { message: text, ...opts });
+  async reply(text, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendMessage(peer, { message: text, ...opts });
   }
 }
 
@@ -135,21 +167,30 @@ class Bot {
       }
     }, new NewMessage({}));
 
-    this.client.addEventHandler(async (event) => {
-      try {
-        const ctx = new CallbackContext(this.client, event);
-
-        for (const h of this.handlers.action) {
-          const matched =
-            h.pattern instanceof RegExp
-              ? h.pattern.test(ctx.data)
-              : ctx.data === h.pattern;
-          if (matched) return await h.fn(ctx);
+    if (CallbackQuery) {
+      this.client.addEventHandler(async (event) => {
+        try {
+          const ctx = new CallbackContext(this.client, event);
+
+          for (const h of this.handlers.action) {
+            const matched =
+              h.pattern instanceof RegExp
+                ? h.pattern.test(ctx.data)
+                : ctx.data === h.pattern;
+            if (matched) return await h.fn(ctx);
+          }
+        } catch (err) {
+          console.error("[xzcgram] action handler error:", err);
         }
-      } catch (err) {
-        console.error("[xzcgram] action handler error:", err);
-      }
-    }, new NewCallbackQuery({}));
+      }, new CallbackQuery({}));
+    } else if (this.handlers.action.length > 0) {
+      console.warn(
+        "[xzcgram] bot.action() handlers were registered, but this version " +
+          "of the 'telegram' package doesn't expose a CallbackQuery event " +
+          "class — inline button presses won't be handled. Try updating " +
+          "the 'telegram' package."
+      );
+    }
   }
 }
 

package/src/context.js

@@ -33,7 +33,7 @@ class Context {
     this.event = event;
     /** Raw GramJS message object */
     this.message = event.message;
-    /** Chat/peer id where the message was sent */
+    /** Chat/peer id where the message was sent (numeric, informational) */
     this.chatId = this.message.chatId;
     /** Full text of the incoming message */
     this.text = this.message.message || "";
@@ -41,18 +41,38 @@ class Context {
     this.args = this.text.split(" ").slice(1);
   }
 
+  /**
+   * Resolves the correct peer to send to/act on.
+   * Uses message.getInputChat() first, since it carries the access_hash
+   * from the incoming update — this avoids "Could not find the input
+   * entity" errors that happen when using a raw numeric chatId for a
+   * user/chat the client hasn't cached yet (e.g. first DM from someone new).
+   * Falls back to the raw chatId if getInputChat() can't resolve anything.
+   */
+  async _peer() {
+    try {
+      const inputChat = await this.message.getInputChat();
+      if (inputChat) return inputChat;
+    } catch (err) {
+      // fall through to raw chatId below
+    }
+    return this.chatId;
+  }
+
   // ---------------------------------------------------------------------
   // Text
   // ---------------------------------------------------------------------
 
   /** Reply in the same chat the message came from. */
-  reply(text, opts = {}) {
-    return this.client.sendMessage(this.chatId, { message: text, ...opts });
+  async reply(text, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendMessage(peer, { message: text, ...opts });
   }
 
   /** Reply directly to the triggering message (quote-style reply). */
-  replyQuote(text, opts = {}) {
-    return this.client.sendMessage(this.chatId, {
+  async replyQuote(text, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendMessage(peer, {
       message: text,
       replyTo: this.message.id,
       ...opts,
@@ -60,8 +80,9 @@ class Context {
   }
 
   /** Edit a message previously sent in this chat (must be your own message). */
-  editMessage(messageId, text, opts = {}) {
-    return this.client.editMessage(this.chatId, {
+  async editMessage(messageId, text, opts = {}) {
+    const peer = await this._peer();
+    return this.client.editMessage(peer, {
       message: messageId,
       text,
       ...opts,
@@ -73,13 +94,15 @@ class Context {
   // ---------------------------------------------------------------------
 
   /** Send a photo. `file` can be a path, Buffer, URL, or existing file id. */
-  replyWithPhoto(file, opts = {}) {
-    return this.client.sendFile(this.chatId, { file, ...opts });
+  async replyWithPhoto(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, { file, ...opts });
   }
 
   /** Send a video. Pass `opts.supportsStreaming = true` for streamable playback. */
-  replyWithVideo(file, opts = {}) {
-    return this.client.sendFile(this.chatId, {
+  async replyWithVideo(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, {
       file,
       supportsStreaming: true,
       ...opts,
@@ -87,23 +110,27 @@ class Context {
   }
 
   /** Send a round "video note" (the circular video bubble). */
-  replyWithVideoNote(file, opts = {}) {
-    return this.client.sendFile(this.chatId, { file, videoNote: true, ...opts });
+  async replyWithVideoNote(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, { file, videoNote: true, ...opts });
   }
 
   /** Send an audio file (music, shown with player + duration/title). */
-  replyWithAudio(file, opts = {}) {
-    return this.client.sendFile(this.chatId, { file, ...opts });
+  async replyWithAudio(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, { file, ...opts });
   }
 
   /** Send a voice note (the waveform bubble). */
-  replyWithVoice(file, opts = {}) {
-    return this.client.sendFile(this.chatId, { file, voiceNote: true, ...opts });
+  async replyWithVoice(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, { file, voiceNote: true, ...opts });
   }
 
   /** Send any file as a generic document. */
-  replyWithDocument(file, opts = {}) {
-    return this.client.sendFile(this.chatId, {
+  async replyWithDocument(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, {
       file,
       forceDocument: true,
       ...opts,
@@ -111,13 +138,15 @@ class Context {
   }
 
   /** Send a sticker (.webp/.tgs file or existing file reference). */
-  replyWithSticker(file, opts = {}) {
-    return this.client.sendFile(this.chatId, { file, ...opts });
+  async replyWithSticker(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, { file, ...opts });
   }
 
   /** Send an animated GIF. */
-  replyWithAnimation(file, opts = {}) {
-    return this.client.sendFile(this.chatId, {
+  async replyWithAnimation(file, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, {
       file,
       attributes: [new Api.DocumentAttributeAnimated()],
       ...opts,
@@ -125,8 +154,9 @@ class Context {
   }
 
   /** Send multiple files as an album/media group. `files` is an array. */
-  replyWithMediaGroup(files, opts = {}) {
-    return this.client.sendFile(this.chatId, { file: files, ...opts });
+  async replyWithMediaGroup(files, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendFile(peer, { file: files, ...opts });
   }
 
   // ---------------------------------------------------------------------
@@ -139,8 +169,9 @@ class Context {
    * @param {Array<Array<{text: string, data?: string, url?: string}>>} rows
    * @param {object} [opts]
    */
-  replyWithButtons(text, rows, opts = {}) {
-    return this.client.sendMessage(this.chatId, {
+  async replyWithButtons(text, rows, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendMessage(peer, {
       message: text,
       buttons: buildButtons(rows, true),
       ...opts,
@@ -153,8 +184,9 @@ class Context {
    * @param {Array<Array<{text: string}>>} rows
    * @param {object} [opts]
    */
-  replyWithKeyboard(text, rows, opts = {}) {
-    return this.client.sendMessage(this.chatId, {
+  async replyWithKeyboard(text, rows, opts = {}) {
+    const peer = await this._peer();
+    return this.client.sendMessage(peer, {
       message: text,
       buttons: buildButtons(rows, false),
       ...opts,
@@ -167,17 +199,24 @@ class Context {
    * @param {string[]} answers
    * @param {object} [opts] e.g. { multipleChoice: true, quiz: false }
    */
-  replyWithPoll(question, answers, opts = {}) {
+  async replyWithPoll(question, answers, opts = {}) {
+    const peer = await this._peer();
     return this.client.invoke(
       new Api.messages.SendMedia({
-        peer: this.chatId,
+        peer,
         media: new Api.InputMediaPoll({
           poll: new Api.Poll({
             id: BigInt(Date.now()),
-            question,
+            question: new Api.TextWithEntities({
+              text: question,
+              entities: [],
+            }),
             answers: answers.map(
               (text, i) =>
-                new Api.PollAnswer({ text, option: Buffer.from([i]) })
+                new Api.PollAnswer({
+                  text: new Api.TextWithEntities({ text, entities: [] }),
+                  option: Buffer.from([i]),
+                })
             ),
             multipleChoice: !!opts.multipleChoice,
           }),
@@ -189,10 +228,11 @@ class Context {
   }
 
   /** Send a geographic location. */
-  replyWithLocation(latitude, longitude, opts = {}) {
+  async replyWithLocation(latitude, longitude, opts = {}) {
+    const peer = await this._peer();
     return this.client.invoke(
       new Api.messages.SendMedia({
-        peer: this.chatId,
+        peer,
         media: new Api.InputMediaGeoPoint({
           geoPoint: new Api.InputGeoPoint({ lat: latitude, long: longitude }),
         }),
@@ -204,10 +244,11 @@ class Context {
   }
 
   /** Send a contact card. */
-  replyWithContact(phoneNumber, firstName, lastName = "", opts = {}) {
+  async replyWithContact(phoneNumber, firstName, lastName = "", opts = {}) {
+    const peer = await this._peer();
     return this.client.invoke(
       new Api.messages.SendMedia({
-        peer: this.chatId,
+        peer,
         media: new Api.InputMediaContact({
           phoneNumber,
           firstName,
@@ -222,10 +263,11 @@ class Context {
   }
 
   /** Send an animated dice/emoji reaction (🎲 🎯 🏀 ⚽ 🎰 🎳). */
-  replyWithDice(emoji = "🎰", opts = {}) {
+  async replyWithDice(emoji = "🎲", opts = {}) {
+    const peer = await this._peer();
     return this.client.invoke(
       new Api.messages.SendMedia({
-        peer: this.chatId,
+        peer,
         media: new Api.InputMediaDice({ emoticon: emoji }),
         message: "",
         randomId: BigInt(Date.now()),
@@ -239,32 +281,37 @@ class Context {
   // ---------------------------------------------------------------------
 
   /** Delete the triggering message (revokes for everyone by default). */
-  deleteMessage() {
-    return this.client.deleteMessages(this.chatId, [this.message.id], {
+  async deleteMessage() {
+    const peer = await this._peer();
+    return this.client.deleteMessages(peer, [this.message.id], {
       revoke: true,
     });
   }
 
   /** Forward the triggering message to another chat. */
-  forwardMessage(toChatId) {
+  async forwardMessage(toChatId) {
+    const peer = await this._peer();
     return this.client.forwardMessages(toChatId, {
       messages: [this.message.id],
-      fromPeer: this.chatId,
+      fromPeer: peer,
     });
   }
 
   /** Pin the triggering message in the current chat. */
-  pinMessage(opts = {}) {
-    return this.client.pinMessage(this.chatId, this.message.id, opts);
+  async pinMessage(opts = {}) {
+    const peer = await this._peer();
+    return this.client.pinMessage(peer, this.message.id, opts);
   }
 
   /** Unpin the triggering message in the current chat. */
-  unpinMessage() {
-    return this.client.unpinMessage(this.chatId, this.message.id);
+  async unpinMessage() {
+    const peer = await this._peer();
+    return this.client.unpinMessage(peer, this.message.id);
   }
 
   /** Show the "typing..." / "sending photo..." indicator. */
-  sendChatAction(action = "typing") {
+  async sendChatAction(action = "typing") {
+    const peer = await this._peer();
     const actions = {
       typing: new Api.SendMessageTypingAction(),
       photo: new Api.SendMessageUploadPhotoAction({ progress: 0 }),
@@ -275,7 +322,7 @@ class Context {
     };
     return this.client.invoke(
       new Api.messages.SetTyping({
-        peer: this.chatId,
+        peer,
         action: actions[action] || actions.typing,
       })
     );