@xbibzlibrary/telebibz 0.4.5 → 3.1.1

package/lib/menus.js

@@ -0,0 +1,90 @@
+// lib/menus.js — Menu inline ala @grammyjs/menu (mandiri, tanpa dep tambahan).
+'use strict';
+
+const { Composer } = require('./composer');
+
+const re = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * const menu = new Menu('cfg');
+ * menu.text('🔔 Notif', async (ctx) => ctx.answerCallbackQuery('ditekan!'))
+ *     .row()
+ *     .url('Web', 'https://x')
+ *     .submenu('Lanjut ▶', 'cfg-lanjut');
+ *
+ * bot.use(menu);                          // handler tombol terdaftar otomatis
+ * bot.cmd('cfg', async (ctx) =>
+ *   ctx.reply('Menu:', { reply_markup: await menu.render(ctx) }));
+ */
+class Menu extends Composer {
+  constructor(id) {
+    super();
+    this.id = id;
+    this._ops = [];
+    this.callbackQuery(new RegExp(`^${re(id)}\\|`), async (ctx) => {
+      const i = Number(ctx.callback_query.data.slice(id.length + 1));
+      const op = this._ops[i];
+      if (!op) return ctx.answerCallbackQuery({ text: '⌛ Tombol usang — kirim ulang menunya', show_alert: true }).catch(() => {});
+      if (op.type === 'text' && op.handler) return op.handler(ctx);
+      if (op.type === 'submenu') {
+        const target = this._menus && this._menus.get(op.target);
+        if (target) {
+          try { await ctx.editMessageReplyMarkup({ reply_markup: await target.render(ctx) }); }
+          catch { /* pesan mungkin termodifikasi */ }
+          return ctx.answerCallbackQuery().catch(() => {});
+        }
+      }
+      return ctx.answerCallbackQuery().catch(() => {});
+    });
+  }
+
+  _add(o) { this._ops.push(o); return this; }
+
+  /** Tombol teks + handler saat ditekan. */
+  text(label, handler) { return this._add({ type: 'text', label, handler }); }
+  /** Tombol tautan. */
+  url(label, link, opts = {}) { return this._add({ type: 'url', label, link, opts }); }
+  /** Tombol WebApp. */
+  webApp(label, link) { return this._add({ type: 'webApp', label, link }); }
+  /** Tombol pindah ke menu lain dengan id target (Menu diregister lewat container). */
+  submenu(label, targetId) { return this._add({ type: 'submenu', label, target: targetId }); }
+  /** Baris baru. */
+  row() { return this._add({ type: 'row' }); }
+  /** Shortcut: kembali ke menu parent. */
+  back(label = '◀️ Kembali', parentId) { return this.submenu(label, parentId); }
+
+  /** Render keyboard (inline_keyboard). */
+  async render(ctx) {
+    const rows = [[]];
+    const push = (b) => rows[rows.length - 1].push(b);
+    for (let i = 0; i < this._ops.length; i++) {
+      const o = this._ops[i];
+      if (o.type === 'row') { rows.push([]); continue; }
+      if (o.type === 'url') { push({ text: o.label, url: o.link, ...(o.opts.style ? { style: o.opts.style } : {}), ...(o.opts.iconId ? { icon_custom_emoji_id: o.opts.iconId } : {}) }); continue; }
+      if (o.type === 'webApp') { push({ text: o.label, web_app: { url: o.link } }); continue; }
+      push({ text: o.label, callback_data: `${this.id}|${i}` });
+    }
+    return { inline_keyboard: rows.filter((r) => r.length) };
+  }
+}
+
+/**
+ * Wadah beberapa menu terkait (dengan submenu silang):
+ *   const mc = new MenuContainer();
+ *   const utama = mc.create('utama'), lanjut = mc.create('lanjut');
+ *   utama.submenu('Lanjut ▶', 'lanjut'); lanjut.back('◀️', 'utama');
+ *   bot.use(mc);
+ */
+class MenuContainer extends Composer {
+  constructor() { super(); this._menus = new Map(); }
+  create(id) {
+    const m = new Menu(id);
+    m._menus = this._menus;
+    this._menus.set(id, m);
+    this.use(m);
+    return m;
+  }
+  get(id) { return this._menus.get(id); }
+}
+
+module.exports = { Menu, MenuContainer };

package/lib/net.js

@@ -0,0 +1,115 @@
+// lib/net.js — transport Bot API production-grade (axios keep-alive, proxy, timeout,
+// multipart attach://, 429 retry_after handler, debug logging).
+'use strict';
+
+const axios = require('axios');
+const http = require('http');
+const https = require('https');
+const dbg = require('debug')('telebibz:net');
+let HttpsProxyAgent = null;
+try { ({ HttpsProxyAgent } = require('https-proxy-agent')); } catch { /* proxy opsional */ }
+
+const { File } = require('./file');
+const mime = require('mime-types');
+
+/** Error API Telegram dengan konteks debugging. */
+class ApiError extends Error {
+  constructor(description, errorCode, method, payload, parameters) {
+    super(description);
+    this.name = 'ApiError';
+    this.description = description;
+    this.error_code = errorCode;
+    this.parameters = parameters || {};
+    this.method = method;
+    this.payload = payload;
+  }
+}
+
+const keepAliveHttp = new http.Agent({ keepAlive: true, maxSockets: 64 });
+const keepAliveHttps = new https.Agent({ keepAlive: true, maxSockets: 64 });
+
+/**
+ * Bangun fungsi transport (method, payload) => result.
+ * opts: { apiRoot, proxy, timeoutMs, headers }
+ */
+function createTransport(token, opts = {}) {
+  const apiRoot = (opts.apiRoot || 'https://api.telegram.org').replace(/\/$/, '');
+  const agent = opts.proxy && HttpsProxyAgent ? new HttpsProxyAgent(opts.proxy) : keepAliveHttps;
+  const client = axios.create({
+    baseURL: `${apiRoot}/bot${token}/`,
+    httpAgent: keepAliveHttp,
+    httpsAgent: agent,
+    timeout: opts.timeoutMs || 35000, // sedikit > long-poll 25s
+    headers: opts.headers || {},
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+    proxy: false, // kendalikan lewat httpsAgent sendiri
+  });
+
+  return async function transport(method, payload = {}) {
+    dbg('--> %s %s', method, JSON.stringify(payload, safeReplacer).slice(0, 400));
+    const files = [];
+    // Deep-walk: File di MANA PUN (media[i].media, photo top-level, thumbnail, dll)
+    const clean = collectAttach(payload, files);
+
+    let data, config = {};
+    if (files.length) {
+      const fd = new FormData();
+      for (const [k, v] of Object.entries(clean)) fd.append(k, typeof v === 'object' ? JSON.stringify(v) : String(v));
+      for (const [an, f] of files) {
+        const buf = await f.data();
+        fd.append(an, new Blob([buf], { type: f.type || mime.lookup(f.filename) || 'application/octet-stream' }), f.filename || an);
+      }
+      data = fd;
+    } else {
+      data = JSON.stringify(clean);
+      config.headers = { 'Content-Type': 'application/json' };
+    }
+
+    let res;
+    try {
+      res = await client.post(method, data, config);
+    } catch (err) {
+      if (err.response && err.response.data) {
+        const d = err.response.data;
+        dbg('<-- ERR %s: %s', method, d.description);
+        throw new ApiError(d.description || `HTTP ${err.response.status}`, d.error_code || err.response.status, method, payload, d.parameters);
+      }
+      // error jaringan murni: tag agar Runner menganggapnya sementara
+      err.network = !err.response;
+      dbg('<-- NETWORK ERR %s: %s', method, err.message);
+      throw err;
+    }
+    const env = res.data;
+    if (!env.ok) {
+      dbg('<-- ERR %s: %s', method, env.description);
+      throw new ApiError(env.description || 'unknown error', env.error_code, method, payload, env.parameters);
+    }
+    dbg('<-- OK %s', method);
+    return env.result;
+  };
+}
+
+/** Rekursif: salin payload sambil mengganti File jadi "attach://fileN". */
+function collectAttach(value, files) {
+  if (value instanceof File) {
+    const an = `file${files.length}`;
+    files.push([an, value]);
+    return `attach://${an}`;
+  }
+  if (Array.isArray(value)) return value.map((v) => collectAttach(v, files));
+  if (value && typeof value === 'object') {
+    const o = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === undefined || v === null) continue;
+      o[k] = collectAttach(v, files);
+    }
+    return o;
+  }
+  return value;
+}
+
+/** JSON.stringify yang aman terhadap File (untuk debug log). */
+function safeReplacer(k, v) { return v instanceof File ? `<File:${v.filename}>` : v; }
+
+module.exports = { createTransport, ApiError };

package/lib/ratelimit.js

@@ -0,0 +1,61 @@
+// lib/ratelimit.js — auto-retry 429, throttler antre, dan batas laju per-user.
+'use strict';
+
+const dbg = require('debug')('telebibz:ratelimit');
+
+/** Transformer 429: hormati retry_after Telegram (maks maxRetry kali).
+ *  Pasang: bot.api.config.use(autoRetry()) */
+function autoRetry({ maxRetry = 5, baseDelayMs = 500 } = {}) {
+  return async (prev, method, payload) => {
+    let attempt = 0;
+    for (;;) {
+      try { return await prev(method, payload); }
+      catch (err) {
+        const ra = err && err.parameters && err.parameters.retry_after;
+        if (ra !== undefined && attempt < maxRetry) {
+          attempt++;
+          const wait = ra * 1000 + baseDelayMs * attempt;
+          dbg('429 pada %s — tidur %dms (attempt %d)', method, wait, attempt);
+          await new Promise((r) => setTimeout(r, wait));
+          continue;
+        }
+        throw err;
+      }
+    }
+  };
+}
+
+/** Transformer antrean: jaga maks `perSecond` panggilan API global.
+ *  Pasang: bot.api.config.use(throttler()) */
+function throttler({ perSecond = 28 } = {}) {
+  const interval = 1000 / perSecond;
+  let last = 0; let chain = Promise.resolve();
+  return (prev, method, payload) => {
+    chain = chain.then(async () => {
+      const wait = last + interval - Date.now();
+      if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+      last = Date.now();
+      return prev(method, payload);
+    });
+    return chain;
+  };
+}
+
+/** Middleware anti-spam: maks `limit` update per user per `windowMs`. */
+function limiter({ windowMs = 2000, limit = 3, onExceeded } = {}) {
+  const bucket = new Map();
+  return async (ctx, next) => {
+    const key = ctx.from ? ctx.from.id : (ctx.chatId || '?');
+    const now = Date.now();
+    const arr = bucket.get(key) || [];
+    const alive = arr.filter((t) => now - t < windowMs);
+    if (alive.length >= limit) {
+      if (onExceeded) return onExceeded(ctx);
+      return; // diamkan spam
+    }
+    alive.push(now); bucket.set(key, alive);
+    return next();
+  };
+}
+
+module.exports = { autoRetry, throttler, limiter };

package/lib/runner.js

@@ -0,0 +1,45 @@
+// lib/runner.js — long polling tahan banting (retry 409 & jaringan, backoff halus).
+'use strict';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Loop getUpdates; memanggil handleUpdate per update.
+ *   stop() mengamaninya keluar loop dengan bersih.
+ * Perilaku:
+ *  - error jaringan (fetch gagal)      → retry 1 dtk
+ *  - 409 (instance lain masih polling) → log callback onConflict + retry 5 dtk
+ *  - error API lain                    → oper ke onFatal (default: berhenti bersih)
+ */
+async function pollLoop({ api, handleUpdate, allowedUpdates, dropPending, onConflict, onFatal, shouldStop, conflictDelay = 5000 }) {
+  let offset = 0;
+  if (dropPending) {
+    try {
+      const u = await api.callApi('getUpdates', { offset: -1, timeout: 0, allowed_updates: allowedUpdates });
+      if (u.length) offset = u[u.length - 1].update_id + 1;
+    } catch { /* abaikan — loop utama yang menangani */ }
+  }
+
+  while (!shouldStop()) {
+    let updates;
+    try {
+      updates = await api.callApi('getUpdates', { offset, timeout: 25, allowed_updates: allowedUpdates });
+      if (!Array.isArray(updates)) updates = [];
+    } catch (err) {
+      const code = err && (err.error_code || err.code);
+      if (shouldStop()) break;
+      if (code === 409) { if (onConflict) onConflict(err); await sleep(conflictDelay); continue; }
+      const fatal = code && code !== 429;
+      if (fatal) { if (onFatal) onFatal(err); break; }
+      await sleep(1000); continue; // koneksi putus / 429 → napas sebentar
+    }
+
+    for (const u of updates) {
+      if (shouldStop()) break;
+      offset = u.update_id + 1;
+      try { await handleUpdate(u); } catch { /* sudah ditangani error handler bot */ }
+    }
+  }
+}
+
+module.exports = { pollLoop };

package/lib/session.js

@@ -0,0 +1,36 @@
+// lib/session.js — sesi per-user-per-chat, tanpa konfigurasi.
+'use strict';
+
+/**
+ * session({ initial, getKey, storage })
+ *  - default getKey: from.id + chat.id (khas), fallback chat.id.
+ *  - default storage: Map di memori. Boleh kirim storage custom { read(key), write(key,val), delete(key) }.
+ */
+function session(opts = {}) {
+  const initial = opts.initial || (() => ({}));
+  const store = opts.storage || new Map();
+  const getKey = opts.getKey || ((ctx) => {
+    const from = ctx.from && ctx.from.id;
+    const chat = ctx.chat && ctx.chat.id;
+    if (from !== undefined && chat !== undefined) return `${from}:${chat}`;
+    return chat !== undefined ? String(chat) : undefined;
+  });
+
+  const read = (k) => (store.read ? store.read(k) : store.get(k));
+  const write = (k, v) => (store.write ? store.write(k, v) : store.set(k, v));
+  const del = (k) => (store.delete ? store.delete(k) : store.delete(k));
+
+  return async (ctx, next) => {
+    const key = getKey(ctx);
+    if (key === undefined) { ctx.session = {}; return next(); }
+    let s = await read(key);
+    if (s === undefined || s === null) { s = initial(); await write(key, s); }
+    // Proxy: properti __deleted di akhir → hapus dari store
+    ctx.session = new Proxy(s, {
+      get: (t, p) => t[p], set: (t, p, v) => { t[p] = v; return true; },
+    });
+    return next();
+  };
+}
+
+module.exports = { session };

package/lib/telebibz.js

@@ -0,0 +1,193 @@
+// lib/telebibz.js — kelas utama: 100% kode sendiri, 0 dependency.
+'use strict';
+
+const { makeApi } = require('./api');
+const { Context } = require('./context');
+const { Composer } = require('./composer');
+const { session } = require('./session');
+const { matchInlineQuery } = require('./inline-query');
+const { Menu, MenuContainer } = require('./menus');
+const { pollLoop } = require('./runner');
+const wizard = require('./wizard');
+const log = require('./logger');
+const { humanize } = require('./errors');
+const { broadcast } = require('./broadcast');
+
+const DEFAULT_UPDATES = [
+  'message', 'edited_message', 'callback_query', 'inline_query',
+  'my_chat_member', 'chat_member', 'message_reaction',
+  'business_connection', 'business_message', 'edited_business_message',
+];
+
+class TeleBibz {
+  /**
+   * new TeleBibz('123:ABC', {
+   *   allowedUpdates: [...], onError(err, ctx), silent, dropPending,
+   *   transport: (method, payload) => Promise<result>,   // ← suntik untuk test
+   *   session: {...opsi session}, apiRoot: 'https://api.telegram.org'
+   * })
+   */
+  constructor(token, opts = {}) {
+    if (!token || !/^\d+:[\w-]+$/.test(token)) {
+      throw new Error('TeleBibz: token tidak valid. Ambil dari @BotFather → /newbot.');
+    }
+    this.opts = opts;
+    this.token = token;
+    this.api = makeApi(token, opts.transport);
+    this.botInfo = undefined;
+
+    this._handlers = new Composer();        // composer publik (use/on/cmd/dll)
+    this._report = async (bare) => {
+      const err = bare && bare.error ? bare.error : bare;
+      const ctx = bare && bare.ctx;
+      if (typeof this.opts.onError === 'function') return this.opts.onError(err, ctx);
+      this.printError(err, ctx);
+    };
+
+    // Pohon eksekusi: session → wizard → user handlers (dilindungi boundary)
+    this._root = new Composer()
+      .use(session(opts.session || {}))
+      .use(wizard.middleware());
+    this._safe = this._root.errorBoundary(this._report);
+  }
+
+  /* ---------- shortcut publik ---------- */
+  use(...mw) { this._handlers.use(...mw); return this; }
+  cmd(names, ...mw) { this._handlers.command(names, ...mw); return this; }
+  hears(match, ...mw) {
+    this._handlers.hears(match instanceof RegExp || Array.isArray(match) ? match : new RegExp(`^${escapeRe(match)}$`, 'i'), ...mw);
+    return this;
+  }
+  action(trigs, ...mw) { this._handlers.callbackQuery(trigs, ...mw); return this; }
+
+  /** Mode inline: bot.inlineQuery(/kucing/, handler) atau bot.inlineQuery('*', h) */
+  branch(...a) { this._handlers.branch(...a); return this; }
+  filter(...a) { this._handlers.filter(...a); return this; }
+  drop(...a) { this._handlers.drop(...a); return this; }
+  route(...a) { this._handlers.route(...a); return this; }
+  lazy(...a) { this._handlers.lazy(...a); return this; }
+  fork(...a) { this._handlers.fork(...a); return this; }
+
+  inlineQuery(trigger, ...mw) { this._handlers.use(async (ctx, next) => (matchInlineQuery(trigger)(ctx) ? runChain(mw, ctx, next) : next())); return this; }
+
+  /** Shortcut shortcut: daftarkan daftar perintah ke tombol menu Telegram. */
+  setMyCommands(commands, extra = {}) { return this.api.setMyCommands(commands, extra); }
+  on(filter, ...mw) { this._handlers.on(filter, ...mw); return this; }
+  start(replies) {
+    const h = typeof replies === 'function' ? replies : async (ctx) => ctx.reply(replies);
+    return this.cmd('start', h);
+  }
+
+  /* ---------- wizard ---------- */
+  wizard(id, def, bindCommand = true) {
+    wizard.define(id, def);
+    if (bindCommand) this.cmd(id, (ctx) => wizard.start(ctx, id));
+    return this;
+  }
+  wizardStart(ctx, id) { return wizard.start(ctx, id); }
+  wizardActive(ctx) { return wizard.active(ctx); }
+  wizardCancel(ctx) { return wizard.cancel(ctx); }
+  wizardEdit(ctx, text, extra) { return wizard.editAsk(ctx, text, extra); }
+  wizardDelete(ctx) { return wizard.deleteAsk(ctx); }
+
+  /* ---------- broadcast ---------- */
+  broadcast(ids, pesan, opts) { return broadcast(this.api, ids, pesan, opts); }
+
+  /* ---------- siklus hidup ---------- */
+
+  /** Ambil identitas bot (dipanggil otomatis oleh launch; panggil manual untuk webhook). */
+  async init() {
+    const me = await this.api.getMe();
+    this.botInfo = me;
+    return me;
+  }
+
+  /** Tangani SATU update mentah (webhook/serverless/test). */
+  async handleUpdate(update) {
+    if (this._wired !== true) this._wire();
+    const ctx = new Context(update, this.api, this.botInfo);
+    try { await this._root.run(ctx); }
+    catch (err) { await this._report({ error: err, ctx }); }
+  }
+
+  _wire() {
+    this._wired = true;
+    // Pasang handler publik SETELAH boundary agar semuanya terlindungi
+    this._root.use(this._handlers.middleware());
+  }
+
+  /** Nyalakan long polling (dengan retry 409 & backoff jaringan). */
+  async launch(launchOpts = {}) {
+    await this.init();
+    const me = this.botInfo;
+    if (!this.opts.silent) {
+      log.banner('🤖 TeleBibz ON', [
+        `bot      : @${me.username} (id ${me.id})`,
+        'mode     : long-polling',
+        `library  : telebibz ${require('../package.json').version} (0 dependency)`,
+        'brand    : //—Xbibz Official—//',
+      ]);
+      log.ok('menunggu update… (Ctrl+C untuk berhenti)');
+    }
+    this._stopping = false;
+    this._runPromise = pollLoop({
+      api: this.api,
+      handleUpdate: (u) => this.handleUpdate(u),
+      allowedUpdates: this.opts.allowedUpdates || DEFAULT_UPDATES,
+      dropPending: this.opts.dropPending || launchOpts.dropPending || false,
+      shouldStop: () => this._stopping,
+      conflictDelay: launchOpts.conflictDelay || 5000,
+      onConflict: () => { if (!this.opts.silent) log.warn('bot lain masih polling (409) — coba lagi 5 detik…'); },
+      onFatal: (err) => this._report({ error: err }),
+    });
+    // Ctrl+C → berhenti bersih
+    if (!this.opts.silent && !launchOpts.noSignalHandlers) {
+      const stop = () => { log.warn('mematikan…'); this.stop(); };
+      process.once('SIGINT', stop); process.once('SIGTERM', stop);
+    }
+    return this;
+  }
+
+  /** Berhenti polling (resolve runPromise). */
+  stop() { this._stopping = true; }
+  /** Promise loop polling — ditunggu utk graceful shutdown/test. */
+  get runPromise() { return this._runPromise; }
+
+  /**
+   * Handler webhook gaya Node/Express:
+   *   const server = bot.webhook();
+   *   http.createServer((req,res) => req.url==='/tg' ? server(req,res) : ...)
+   *   — framework mana pun: (req, res) pasangan Request/Response Node.
+   */
+  webhook() {
+    return async (req, res) => {
+      try {
+        const chunks = [];
+        for await (const c of req) chunks.push(Buffer.from(c));
+        const update = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        await this.handleUpdate(update);
+        res.statusCode = 200; res.setHeader('Content-Type', 'application/json'); res.end('{}');
+      } catch (e) { res.statusCode = 400; res.end('bad request'); }
+    };
+  }
+
+  /* ---------- error cantik ---------- */
+  printError(err, ctx) {
+    const h = humanize(err);
+    log.error(`Telegram error${h.code ? ` (${h.code})` : ''}: ${h.pesan}`);
+    if (h.method) log.error(`  saat memanggil : ${h.method}`);
+    const c = ctx && ctx.chat ? ctx.chat.id : '-';
+    if (c !== '-') log.error(`  di chat        : ${c}`);
+    if (h.saran) log.warn(`  💡 saran: ${h.saran}`);
+  }
+}
+
+function runChain(mws, ctx, next) {
+  let i = 0;
+  const step = () => (i < mws.length ? mws[i++](ctx, step) : next());
+  return step();
+}
+
+function escapeRe(s) { return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+module.exports = { TeleBibz };