mifistix-bot 1.0.0

package/README.md

@@ -0,0 +1,77 @@
+# 🤖 mifistix-bot
+
+Официальный **Node.js SDK** для работы с сервером **Mifistix Bot**. 
+
+Поддерживает **Long Polling (`getUpdates`)**, отправку сообщений, **Inline-клавиатуры**, обработку нажатий по кнопкам (**Callback Query**), автоматический **Heartbeat 30с** и Graceful Shutdown по Ctrl+C.
+
+---
+
+## 🚀 Быстрый старт
+
+### Пример с меню и Inline-клавиатурой
+
+```javascript
+const { BotClient } = require('mifistix-bot'); // или require('./modules/sdk/mifistix-bot-sdk')
+
+const bot = new BotClient({
+  token: 'ВАШ_ТОКЕН_БОТА',
+});
+
+// Клавиатура главного меню
+function mainMenuKeyboard() {
+  return {
+    inline_keyboard: [
+      [{ text: '⚙️ Настройки', callback_data: 'menu:settings' }],
+      [{ text: '📊 Статистика', callback_data: 'menu:stats' }],
+    ],
+  };
+}
+
+// Клавиатура настроек
+function settingsKeyboard() {
+  return {
+    inline_keyboard: [
+      [{ text: '🔔 Уведомления: Вкл', callback_data: 'toggle:notify' }],
+      [{ text: '⬅️ Назад', callback_data: 'menu:main' }],
+    ],
+  };
+}
+
+// Обработка кликов по кнопкам (callback_query)
+bot.callback_query_handler((call) => {
+  const [action, param] = (call.data || '').split(':');
+
+  if (action === 'menu') {
+    if (param === 'settings') {
+      bot.editMessageText('⚙️ Настройки бота:', call.message.chat.id, call.message.message_id, {
+        reply_markup: settingsKeyboard(),
+      });
+    } else {
+      bot.editMessageText('🏠 Главное меню:', call.message.chat.id, call.message.message_id, {
+        reply_markup: mainMenuKeyboard(),
+      });
+    }
+    bot.answerCallbackQuery(call.id);
+  }
+});
+
+// Запуск бота
+bot.start();
+```
+
+---
+
+## 💡 Полноценный Bot API
+
+SDK предоставляет Telegram-совместимые методы работы с сообщениями:
+
+- **`bot.sendMessage(chat_id, text, reply_markup)`** — отправка сообщения
+- **`bot.editMessageText(text, chat_id, message_id, reply_markup)`** — редактирование сообщения
+- **`bot.answerCallbackQuery(callback_query_id, options)`** — подтверждение нажатия кнопки
+- **`bot.callback_query_handler(filterFn, handlerFn)`** — подписка на клики клавиатуры
+
+---
+
+## 📄 Лицензия
+
+MIT © Mifistix

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "mifistix-bot",
+  "version": "1.0.0",
+  "description": "SDK for Mifistix Bot Server",
+  "main": "src/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "node --test"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}

package/src/client.js

@@ -0,0 +1,486 @@
+const http = require('node:http');
+const https = require('node:https');
+
+function requestJson(url, options = {}, bodyData = null) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+    const reqOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: options.method || 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'mifistix-bot-sdk/1.0.0',
+        ...(options.headers || {}),
+      },
+    };
+
+    const req = transport.request(reqOptions, (res) => {
+      let chunks = '';
+      res.on('data', (chunk) => (chunks += chunk));
+      res.on('end', () => {
+        let json = null;
+        try {
+          json = chunks ? JSON.parse(chunks) : null;
+        } catch {
+          json = { error: chunks };
+        }
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resolve(json);
+        } else {
+          const err = new Error(json?.error || json?.message || `HTTP ${res.statusCode}`);
+          err.status = res.statusCode;
+          err.data = json;
+          reject(err);
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(err));
+
+    if (bodyData) {
+      req.write(JSON.stringify(bodyData));
+    }
+
+    req.end();
+  });
+}
+
+class BotClient {
+  constructor(options = {}) {
+    const token = typeof options === 'string' ? options : options.token;
+    if (!token || typeof token !== 'string') {
+      throw new Error('[mifistix-bot] Токен бота обязателен');
+    }
+
+    this.token = token.trim();
+    // The platform address belongs to the SDK configuration, not bot code.
+    this.serverUrl = (options.serverUrl || process.env.MIFISTIX_SERVER_URL || 'https://bots-api.mifistix.com.pl').replace(/\/+$/, '');
+    this.heartbeatIntervalMs = options.heartbeatIntervalMs || 30_000;
+    this.pollIntervalMs = options.pollIntervalMs || 5_000;
+    this.autoRunning = options.autoRunning !== false;
+    this.enablePolling = options.enablePolling !== false;
+    this.onStatusChange = options.onStatusChange || null;
+    this.onError = options.onError || ((err) => console.error('[mifistix-bot] Ошибка:', err.message));
+
+    this.bot = null;
+    this.botId = null;
+    this.accountId = null;
+    this.currentStatus = null;
+    this.heartbeatTimer = null;
+    this.pollTimer = null;
+    this.started = false;
+    this.polling = false;
+    this.updateOffset = 0;
+
+    this.messageHandlers = [];
+    this.commandHandlers = new Map();
+    this.callbackHandlers = [];
+    this.sigintHandler = null;
+    this.sigtermHandler = null;
+  }
+
+  #request(url, options = {}, bodyData = null) {
+    if (!this.accountId) {
+      throw new Error('[mifistix-bot] SDK не получил ключ accountId');
+    }
+    return requestJson(url, {
+      ...options,
+      headers: {
+        ...(options.headers || {}),
+        'x-mifistix-account-id': this.accountId,
+        'x-mifistix-bot-token': this.token,
+      },
+    }, bodyData);
+  }
+
+  async start() {
+    if (this.started) return this;
+
+    console.log('[mifistix-bot] Подключение к серверу:', this.serverUrl);
+
+    // 1. Авторизация и проверка токена
+    let res;
+    try {
+      res = await requestJson(`${this.serverUrl}/api/bots/login`, { method: 'POST' }, { token: this.token });
+    } catch (error) {
+      throw new Error(`[mifistix-bot] Ошибка авторизации: ${error.message}`);
+    }
+    if (!res?.id || !res?.accountId) {
+      throw new Error('[mifistix-bot] Сервер не вернул botId или accountId');
+    }
+    this.bot = res;
+    this.botId = res.id;
+    this.accountId = String(res.accountId);
+    this.currentStatus = res.status || 'running';
+
+    console.log(`[mifistix-bot] Успешный вход! Бот: "${this.bot.name || this.bot.username || this.botId}" [id: ${this.botId}]`);
+
+    // 2. Авто-перевод в статус running
+    if (this.autoRunning && this.currentStatus !== 'running') {
+      await this.setStatus('running');
+    }
+
+    // 3. Запуск Heartbeat (каждые 30 секунд)
+    this.heartbeatTimer = setInterval(() => this.#sendHeartbeat(), this.heartbeatIntervalMs);
+    this.heartbeatTimer.unref?.();
+
+    // 4. Запуск опроса статуса на сервере (каждые 5 секунд)
+    this.pollTimer = setInterval(() => this.#pollStatus(), this.pollIntervalMs);
+    this.pollTimer.unref?.();
+
+    // 5. Запуск Long Polling для getUpdates
+    // The polling loop checks `started` immediately, so set it before starting.
+    this.started = true;
+
+    if (this.enablePolling) {
+      this.polling = true;
+      this.#pollUpdatesLoop().catch((err) => {
+        if (this.onError) this.onError(err);
+      });
+    }
+
+    // 6. Обработка сигналов завершения работы (Ctrl+C)
+    this.#setupGracefulShutdown();
+
+    return this;
+  }
+
+  async setStatus(status) {
+    if (!this.botId) return;
+    const url = `${this.serverUrl}/api/bots/${this.botId}/status`;
+    const res = await this.#request(url, { method: 'PATCH' }, { status });
+    const oldStatus = this.currentStatus;
+    this.currentStatus = res?.bot ? res.bot.status : (res?.status || status);
+
+    if (oldStatus !== this.currentStatus) {
+      console.log(`[mifistix-bot] Статус изменён: ${oldStatus || '—'} ➔ ${this.currentStatus}`);
+      if (this.onStatusChange) {
+        this.onStatusChange(this.currentStatus, oldStatus);
+      }
+    }
+
+    return this.currentStatus;
+  }
+
+  /* ---------------- Telegram-compatible Bot API Methods ---------------- */
+
+  async sendMessage(chat_id, text, reply_markup = null) {
+    if (typeof chat_id === 'object' && chat_id !== null) {
+      ({ chat_id, text, reply_markup = null } = chat_id);
+    }
+    const url = `${this.serverUrl}/bot${this.token}/sendMessage`;
+    const body = {
+      chat_id,
+      text,
+      reply_markup: typeof reply_markup === 'object' ? reply_markup : null,
+    };
+
+    try {
+      const res = await this.#request(url, { method: 'POST' }, body);
+      return res?.result || res;
+    } catch {
+      const fallbackUrl = `${this.serverUrl}/api/bot/${encodeURIComponent(this.token)}/sendMessage`;
+      const res = await this.#request(fallbackUrl, { method: 'POST' }, body);
+      return res?.result || res;
+    }
+  }
+
+  async editMessageText(text, chat_id, message_id, reply_markup = null) {
+    // В телеграм формате: edit_message_text(text, chat_id, message_id, reply_markup)
+    let cId = chat_id;
+    let mId = message_id;
+    let markup = reply_markup;
+
+    // Если аргументы переданы объектом { chat_id, message_id, text, reply_markup }
+    if (typeof text === 'object' && text !== null) {
+      cId = text.chat_id;
+      mId = text.message_id;
+      markup = text.reply_markup;
+      text = text.text;
+    }
+
+    const url = `${this.serverUrl}/bot${this.token}/editMessageText`;
+    const body = {
+      chat_id: cId,
+      message_id: mId,
+      text,
+      reply_markup: markup || null,
+    };
+
+    try {
+      const res = await this.#request(url, { method: 'POST' }, body);
+      return res?.result || res;
+    } catch {
+      const fallbackUrl = `${this.serverUrl}/api/bot/${encodeURIComponent(this.token)}/editMessageText`;
+      const res = await this.#request(fallbackUrl, { method: 'POST' }, body);
+      return res?.result || res;
+    }
+  }
+
+  // Alias python-style edit_message_text
+  async edit_message_text(text, chat_id, message_id, reply_markup = null) {
+    return this.editMessageText(text, chat_id, message_id, reply_markup);
+  }
+
+  // Telegram-style alias.
+  async send_message(chat_id, text, reply_markup = null) {
+    return this.sendMessage(chat_id, text, reply_markup);
+  }
+
+  async getMe() {
+    const url = `${this.serverUrl}/bot${this.token}/getMe`;
+    try {
+      const res = await this.#request(url);
+      return res?.result || res;
+    } catch {
+      const fallbackUrl = `${this.serverUrl}/api/bot/${encodeURIComponent(this.token)}/getMe`;
+      const res = await this.#request(fallbackUrl);
+      return res?.result || res;
+    }
+  }
+
+  async answerCallbackQuery(callback_query_id, options = {}) {
+    let cbId = callback_query_id;
+    let text = options.text || '';
+    let showAlert = options.show_alert || options.showAlert || false;
+
+    if (typeof callback_query_id === 'object' && callback_query_id !== null) {
+      cbId = callback_query_id.id || callback_query_id.callback_query_id;
+      text = callback_query_id.text || '';
+      showAlert = callback_query_id.show_alert || false;
+    }
+
+    const url = `${this.serverUrl}/bot${this.token}/answerCallbackQuery`;
+    const body = {
+      callback_query_id: cbId,
+      text,
+      show_alert: showAlert,
+    };
+
+    try {
+      const res = await this.#request(url, { method: 'POST' }, body);
+      return res?.result || res;
+    } catch {
+      const fallbackUrl = `${this.serverUrl}/api/bot/${encodeURIComponent(this.token)}/answerCallbackQuery`;
+      const res = await this.#request(fallbackUrl, { method: 'POST' }, body);
+      return res?.result || res;
+    }
+  }
+
+  // Alias python-style answer_callback_query
+  async answer_callback_query(callback_query_id, text = '', show_alert = false) {
+    return this.answerCallbackQuery(callback_query_id, { text, show_alert });
+  }
+
+  /* ---------------- Event Handlers ---------------- */
+
+  onMessage(handler) {
+    if (typeof handler === 'function') {
+      this.messageHandlers.push(handler);
+    }
+    return this;
+  }
+
+  command(command, handler) {
+    const name = String(command || '').replace(/^\//, '').trim().toLowerCase();
+    if (!name || typeof handler !== 'function') {
+      throw new TypeError('command(name, handler) requires a command name and handler');
+    }
+    const handlers = this.commandHandlers.get(name) || [];
+    handlers.push(handler);
+    this.commandHandlers.set(name, handlers);
+    return this;
+  }
+
+  onCallbackQuery(handler) {
+    if (typeof handler === 'function') {
+      this.callbackHandlers.push({ filter: () => true, handler });
+    }
+    return this;
+  }
+
+  // Telegram-style callback_query_handler(func, handler)
+  callback_query_handler(func, handler) {
+    let filter = () => true;
+    let fn = handler;
+
+    if (typeof func === 'function' && typeof handler === 'function') {
+      filter = func;
+      fn = handler;
+    } else if (typeof func === 'function' && !handler) {
+      fn = func;
+    } else if (typeof func === 'string' && typeof handler === 'function') {
+      filter = (call) => call.data === func || call.data?.startsWith(func);
+      fn = handler;
+    }
+
+    if (fn) {
+      this.callbackHandlers.push({ filter, handler: fn });
+    }
+    return this;
+  }
+
+  on(event, handler) {
+    if (event === 'message') return this.onMessage(handler);
+    if (event === 'callback_query') return this.onCallbackQuery(handler);
+    return this;
+  }
+
+  /* ---------------- Internal Polling & Heartbeat ---------------- */
+
+  async #pollUpdatesLoop() {
+    while (this.polling && this.started) {
+      try {
+        const url = `${this.serverUrl}/bot${this.token}/getUpdates?offset=${this.updateOffset}&timeout=20`;
+        let res;
+        try {
+          res = await this.#request(url);
+        } catch {
+          const fallbackUrl = `${this.serverUrl}/api/bot/${encodeURIComponent(this.token)}/getUpdates?offset=${this.updateOffset}&timeout=20`;
+          res = await this.#request(fallbackUrl);
+        }
+
+        const updates = res?.result || [];
+
+        for (const update of updates) {
+          if (update.update_id >= this.updateOffset) {
+            this.updateOffset = update.update_id + 1;
+          }
+
+          if (update.message) {
+            await this.#handleMessage(update.message);
+          }
+          if (update.callback_query) {
+            await this.#handleCallbackQuery(update.callback_query);
+          }
+        }
+      } catch (err) {
+        // Пауза 2с при ошибке сети
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+    }
+  }
+
+  async #handleMessage(message) {
+    const command = String(message.text || '').trim().match(/^\/([^\s@]+)(?:@[^\s]+)?(?:\s|$)/);
+    if (command) {
+      const handlers = this.commandHandlers.get(command[1].toLowerCase()) || [];
+      for (const handler of handlers) {
+        try {
+          await handler(message);
+        } catch (err) {
+          if (this.onError) this.onError(err);
+        }
+      }
+    }
+
+    for (const h of this.messageHandlers) {
+      try {
+        await h(message);
+      } catch (err) {
+        if (this.onError) this.onError(err);
+      }
+    }
+  }
+
+  async #handleCallbackQuery(call) {
+    for (const item of this.callbackHandlers) {
+      try {
+        if (item.filter(call)) {
+          await item.handler(call);
+        }
+      } catch (err) {
+        if (this.onError) this.onError(err);
+      }
+    }
+  }
+
+  async #sendHeartbeat() {
+    try {
+      if (!this.botId || !this.started) return;
+      await this.#request(`${this.serverUrl}/api/bots/${this.botId}/heartbeat`, { method: 'POST' });
+      console.log(`[mifistix-bot] 💓 Heartbeat отправлен (статус: ${this.currentStatus})`);
+    } catch (err) {
+      if (this.onError) this.onError(err);
+    }
+  }
+
+  async #pollStatus() {
+    try {
+      if (!this.botId || !this.started) return;
+      const res = await this.#request(`${this.serverUrl}/api/bots/${this.botId}/status`);
+
+      const serverStatus = res?.bot ? res.bot.status : res?.status;
+      if (serverStatus && serverStatus !== this.currentStatus) {
+        const old = this.currentStatus;
+        this.currentStatus = serverStatus;
+        console.log(`[mifistix-bot] Статус на сервере изменился: ${old} ➔ ${serverStatus}`);
+        if (this.onStatusChange) {
+          this.onStatusChange(serverStatus, old);
+        }
+      }
+    } catch (err) {
+      // Игнорируем ошибки при опросе
+    }
+  }
+
+  #setupGracefulShutdown() {
+    const shutdown = async (signal) => {
+      console.log(`\n[mifistix-bot] Получен сигнал ${signal}. Завершение работы бота...`);
+      await this.stop();
+      process.exit(0);
+    };
+
+    this.sigintHandler = () => shutdown('SIGINT');
+    this.sigtermHandler = () => shutdown('SIGTERM');
+
+    process.once('SIGINT', this.sigintHandler);
+    process.once('SIGTERM', this.sigtermHandler);
+  }
+
+  async stop() {
+    this.polling = false;
+
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+
+    if (this.sigintHandler) {
+      process.removeListener('SIGINT', this.sigintHandler);
+    }
+    if (this.sigtermHandler) {
+      process.removeListener('SIGTERM', this.sigtermHandler);
+    }
+
+    if (this.botId && this.currentStatus === 'running') {
+      try {
+        await this.setStatus('stopped');
+        console.log('[mifistix-bot] Бот остановлен');
+      } catch {
+        /* noop */
+      }
+    }
+
+    this.started = false;
+  }
+}
+
+function start(options) {
+  const client = new BotClient(options);
+  client.start().catch((err) => {
+    console.error('[mifistix-bot] Не удалось запустить бота:', err.message);
+    process.exit(1);
+  });
+  return client;
+}
+
+module.exports = { BotClient, start };

package/src/index.js

@@ -0,0 +1,6 @@
+const { BotClient, start } = require('./client');
+
+module.exports = {
+  BotClient,
+  start,
+};