@xbibzlibrary/telebibz 0.1.0

package/dist-cjs/src/api/errors.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramNetworkError = exports.TelegramValidationError = exports.TelegramAuthError = exports.TelegramRateLimitError = exports.TelegramError = void 0;
+exports.classifyTelegramError = classifyTelegramError;
+exports.telegramErrorFromResponse = telegramErrorFromResponse;
+class TelegramError extends Error {
+    name = "TelegramError";
+    kind;
+    errorCode;
+    parameters;
+    method;
+    payload;
+    status;
+    constructor(message, options) {
+        super(message, { cause: options.cause });
+        this.method = options.method;
+        this.payload = options.payload;
+        this.errorCode = options.errorCode;
+        this.parameters = options.parameters;
+        this.status = options.status;
+        this.kind = options.kind ?? classifyTelegramError(options.errorCode, options.status);
+    }
+    get retryAfter() { return this.parameters?.retry_after; }
+    get migrateToChatId() { return this.parameters?.migrate_to_chat_id; }
+}
+exports.TelegramError = TelegramError;
+class TelegramRateLimitError extends TelegramError {
+    name = "TelegramRateLimitError";
+    constructor(message, options) { super(message, { ...options, kind: "rate-limit" }); }
+}
+exports.TelegramRateLimitError = TelegramRateLimitError;
+class TelegramAuthError extends TelegramError {
+    name = "TelegramAuthError";
+    constructor(message, options) { super(message, { ...options, kind: "authentication" }); }
+}
+exports.TelegramAuthError = TelegramAuthError;
+class TelegramValidationError extends TelegramError {
+    name = "TelegramValidationError";
+    constructor(message, options) { super(message, { ...options, kind: "validation" }); }
+}
+exports.TelegramValidationError = TelegramValidationError;
+class TelegramNetworkError extends TelegramError {
+    name = "TelegramNetworkError";
+    constructor(message, options) { super(message, { ...options, kind: "network" }); }
+}
+exports.TelegramNetworkError = TelegramNetworkError;
+function classifyTelegramError(errorCode, status) {
+    if (errorCode === 429)
+        return "rate-limit";
+    if (errorCode === 401 || status === 401 || status === 403)
+        return "authentication";
+    if (errorCode !== undefined && errorCode >= 400 && errorCode < 500)
+        return "validation";
+    if (status !== undefined && status >= 500)
+        return "server";
+    return "unknown";
+}
+function telegramErrorFromResponse(response, context) {
+    const message = response.description ?? `Telegram API request failed for ${context.method}`;
+    const options = { method: context.method, payload: context.payload };
+    if (response.error_code !== undefined)
+        options.errorCode = response.error_code;
+    if (response.parameters !== undefined)
+        options.parameters = response.parameters;
+    if (context.status !== undefined)
+        options.status = context.status;
+    if (response.error_code === 429)
+        return new TelegramRateLimitError(message, options);
+    if (response.error_code === 401 || context.status === 401 || context.status === 403)
+        return new TelegramAuthError(message, options);
+    if (response.error_code !== undefined && response.error_code >= 400 && response.error_code < 500)
+        return new TelegramValidationError(message, options);
+    return new TelegramError(message, options);
+}

package/dist-cjs/src/api/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./transport.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist-cjs/src/api/transport.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchTransport = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const errors_js_1 = require("./errors.js");
+class FetchTransport {
+    baseUrl;
+    fetchImpl;
+    timeoutMs;
+    retries;
+    backoffMs;
+    maxBackoffMs;
+    jitter;
+    headers;
+    constructor(options = {}) {
+        this.baseUrl = (options.baseUrl ?? "https://api.telegram.org").replace(/\/$/, "");
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+        if (!this.fetchImpl)
+            throw new Error("A fetch implementation is required.");
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.retries = options.retries ?? 2;
+        this.backoffMs = options.backoffMs ?? 250;
+        this.maxBackoffMs = options.maxBackoffMs ?? 8_000;
+        this.jitter = options.jitter ?? 0.2;
+        this.headers = options.headers ?? {};
+    }
+    async request({ method, payload = {}, signal }) {
+        const hasUpload = await containsUpload(payload);
+        let body;
+        const headers = new Headers(this.headers);
+        if (hasUpload) {
+            const form = new FormData();
+            for (const [key, value] of Object.entries(payload))
+                await appendFormValue(form, key, value);
+            body = form;
+        }
+        else {
+            headers.set("content-type", "application/json; charset=utf-8");
+            body = JSON.stringify(payload);
+        }
+        let attempt = 0;
+        while (true) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(new Error(`Request timed out after ${this.timeoutMs}ms`)), this.timeoutMs);
+            const onAbort = () => controller.abort(signal?.reason);
+            signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                const normalizedMethod = method.replace(/^\//, "");
+                const response = await this.fetchImpl(`${this.baseUrl}/${normalizedMethod}`, {
+                    method: "POST",
+                    headers,
+                    body,
+                    signal: controller.signal,
+                });
+                const data = await response.json();
+                return { status: response.status, headers: response.headers, data };
+            }
+            catch (error) {
+                if (signal?.aborted)
+                    throw error;
+                if (attempt >= this.retries || !isRetryableNetworkError(error)) {
+                    throw new errors_js_1.TelegramNetworkError(error instanceof Error ? error.message : "Network request failed", { method, payload, cause: error });
+                }
+                const exponential = Math.min(this.maxBackoffMs, this.backoffMs * 2 ** attempt);
+                const spread = exponential * this.jitter;
+                const delay = Math.max(0, exponential - spread + Math.random() * spread * 2);
+                await new Promise((resolveDelay) => setTimeout(resolveDelay, delay));
+                attempt += 1;
+            }
+            finally {
+                clearTimeout(timeout);
+                signal?.removeEventListener("abort", onAbort);
+            }
+        }
+    }
+}
+exports.FetchTransport = FetchTransport;
+function isRetryableNetworkError(error) {
+    if (!(error instanceof Error))
+        return true;
+    return error.name === "AbortError" || /network|fetch|socket|timeout|temporar/i.test(error.message);
+}
+async function containsUpload(value) {
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer || value instanceof Blob)
+        return true;
+    if (typeof value === "string")
+        return false;
+    if (value && typeof value === "object" && "source" in value)
+        return containsUpload(value.source);
+    if (Array.isArray(value)) {
+        for (const item of value)
+            if (await containsUpload(item))
+                return true;
+    }
+    else if (value && typeof value === "object") {
+        for (const item of Object.values(value))
+            if (await containsUpload(item))
+                return true;
+    }
+    return false;
+}
+async function appendFormValue(form, key, value) {
+    if (value === undefined || value === null)
+        return;
+    if (value instanceof Uint8Array) {
+        form.append(key, new Blob([value]));
+        return;
+    }
+    if (value instanceof ArrayBuffer) {
+        form.append(key, new Blob([value]));
+        return;
+    }
+    if (value instanceof Blob) {
+        form.append(key, value);
+        return;
+    }
+    if (value && typeof value === "object" && "source" in value) {
+        const upload = value;
+        if (typeof upload.source === "string" && ((0, node_path_1.isAbsolute)(upload.source) || upload.source.startsWith("./") || upload.source.startsWith("../"))) {
+            const filePath = (0, node_path_1.resolve)(upload.source);
+            const bytes = await (0, promises_1.readFile)(filePath);
+            form.append(key, new Blob([bytes]), upload.filename ?? (0, node_path_1.basename)(filePath));
+            return;
+        }
+        return appendFormValue(form, key, upload.source);
+    }
+    if (typeof value === "string") {
+        form.append(key, value);
+        return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        form.append(key, String(value));
+        return;
+    }
+    form.append(key, JSON.stringify(value));
+}

package/dist-cjs/src/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/src/approval/approval.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalGate = exports.MemoryApprovalStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../keyboard/index.js");
+class MemoryApprovalStore {
+    records = new Map();
+    async get(key) { const value = this.records.get(key); return value ? { ...value } : undefined; }
+    async set(key, record) { this.records.set(key, { ...record }); }
+    async delete(key) { return this.records.delete(key); }
+}
+exports.MemoryApprovalStore = MemoryApprovalStore;
+class ApprovalGate {
+    api;
+    options;
+    store;
+    cooldownMs;
+    enabled;
+    constructor(api, options) {
+        this.api = api;
+        this.options = options;
+        this.store = options.store ?? new MemoryApprovalStore();
+        this.cooldownMs = options.notificationCooldownMs ?? 10 * 60_000;
+        this.enabled = options.requireApproval ?? true;
+    }
+    async check(identity) {
+        if (!this.enabled)
+            return { allowed: true, status: "disabled" };
+        const key = this.key(identity.bot.id);
+        const current = await this.store.get(key);
+        if (current?.status === "approved")
+            return { allowed: true, status: "approved", record: current };
+        if (current?.status === "pending" && Date.now() - current.requestedAt < this.cooldownMs)
+            return { allowed: false, status: "pending", record: current };
+        const record = {
+            key,
+            botId: identity.bot.id,
+            ownerUserId: identity.configuredOwnerUserId ?? this.options.ownerUserId,
+            status: "pending",
+            nonce: (0, node_crypto_1.randomBytes)(8).toString("hex"),
+            requestedAt: Date.now(),
+        };
+        if (identity.bot.username !== undefined)
+            record.botUsername = identity.bot.username;
+        const ownerLabel = this.options.ownerLabel ?? "Dev Gantenggg";
+        const ownerIdLine = record.ownerUserId ? `Owner ID: ${record.ownerUserId}` : "Owner ID: tidak dikonfigurasi";
+        const botLine = record.botUsername ? `Bot: @${record.botUsername} (ID: ${record.botId})` : `Bot ID: ${record.botId}`;
+        const keyboard = new index_js_1.InlineKeyboard()
+            .text("Izinkan", this.callbackData("approve", record))
+            .text("Tidak Diizinkan", this.callbackData("deny", record))
+            .build();
+        const message = await this.api.methods.sendMessage({
+            chat_id: this.options.ownerChatId,
+            text: `Haloo ${ownerLabel}, ada yang memakai library telebibz nihh\n\n${botLine}\n${ownerIdLine}\nStatus: menunggu izin owner.`,
+            reply_markup: keyboard,
+        });
+        record.notificationMessageId = message.message_id;
+        await this.store.set(key, record);
+        return { allowed: false, status: "pending", record };
+    }
+    async handleCallback(callback) {
+        const data = callback.data ?? "";
+        const parsed = this.parseCallback(data);
+        if (!parsed)
+            return { handled: false };
+        if (callback.from.id !== this.options.ownerUserId) {
+            await this.api.methods.answerCallbackQuery({ callback_query_id: callback.id, text: "Hanya owner yang dapat mengambil keputusan.", show_alert: true });
+            return { handled: true };
+        }
+        const record = await this.store.get(this.key(parsed.botId));
+        if (!record || record.nonce !== parsed.nonce) {
+            await this.api.methods.answerCallbackQuery({ callback_query_id: callback.id, text: "Permintaan izin sudah kedaluwarsa.", show_alert: true });
+            return { handled: true };
+        }
+        const status = parsed.action === "approve" ? "approved" : "denied";
+        record.status = status;
+        record.decidedAt = Date.now();
+        record.decidedBy = callback.from.id;
+        await this.store.set(record.key, record);
+        await this.api.methods.answerCallbackQuery({ callback_query_id: callback.id, text: status === "approved" ? "Bot diizinkan." : "Bot ditolak.", show_alert: false });
+        const message = callback.message;
+        if (message)
+            await this.updateDecisionMessage(message, record, status);
+        return { handled: true, status };
+    }
+    async isAllowed(botId) { return (await this.store.get(this.key(botId)))?.status === "approved" || !this.enabled; }
+    async revoke(botId) { return this.store.delete ? this.store.delete(this.key(botId)) : false; }
+    key(botId) { return `telebibz:approval:${botId}`; }
+    callbackData(action, record) { return `telebibz:approval:${action}:${record.botId}:${record.nonce}`; }
+    parseCallback(data) { const match = /^telebibz:approval:(approve|deny):(\d+):([a-f0-9]{16})$/.exec(data); if (!match)
+        return undefined; return { action: match[1], botId: Number(match[2]), nonce: match[3] }; }
+    async updateDecisionMessage(message, record, status) { const statusText = status === "approved" ? "DIIZINKAN" : "TIDAK DIIZINKAN"; await this.api.methods.editMessageText({ chat_id: message.chat.id, message_id: message.message_id, text: `Permintaan pemakaian telebibz\nBot ID: ${record.botId}${record.botUsername ? `\nBot: @${record.botUsername}` : ""}\nStatus: ${statusText}\nDiputuskan oleh: ${record.decidedBy ?? "owner"}` }); }
+}
+exports.ApprovalGate = ApprovalGate;

package/dist-cjs/src/cache/cache.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenBucketLimiter = exports.MemoryCache = void 0;
+const storage_js_1 = require("../storage/storage.js");
+class MemoryCache {
+    storage = new storage_js_1.MemoryStorage();
+    namespace;
+    constructor(namespace = "telebibz") { this.namespace = namespace; }
+    key(key) { return `${this.namespace}:${key}`; }
+    get(key) { return this.storage.get(this.key(key)); }
+    set(key, value, ttlMs) { return this.storage.set(this.key(key), value, ttlMs === undefined ? {} : { ttlMs }); }
+    delete(key) { return this.storage.delete(this.key(key)); }
+    async invalidate(prefix = "") { const keys = []; for await (const key of this.storage.keys())
+        if (key.startsWith(this.key(prefix)))
+            keys.push(key); for (const key of keys)
+        await this.storage.delete(key); }
+    async getOrSet(key, factory, ttlMs) { const existing = await this.get(key); if (existing !== undefined)
+        return existing; const value = await factory(); await this.set(key, value, ttlMs); return value; }
+}
+exports.MemoryCache = MemoryCache;
+class TokenBucketLimiter {
+    capacity;
+    refillPerSecond;
+    buckets = new Map();
+    constructor(capacity, refillPerSecond) {
+        this.capacity = capacity;
+        this.refillPerSecond = refillPerSecond;
+        if (capacity <= 0 || refillPerSecond <= 0)
+            throw new RangeError("capacity and refillPerSecond must be positive");
+    }
+    consume(key, cost = 1) { const now = Date.now(); const current = this.buckets.get(key) ?? { tokens: this.capacity, updatedAt: now }; const elapsedSeconds = (now - current.updatedAt) / 1000; current.tokens = Math.min(this.capacity, current.tokens + elapsedSeconds * this.refillPerSecond); current.updatedAt = now; if (current.tokens < cost) {
+        const retryAfterMs = Math.ceil(((cost - current.tokens) / this.refillPerSecond) * 1000);
+        this.buckets.set(key, current);
+        return { allowed: false, remaining: Math.floor(current.tokens), resetAt: now + retryAfterMs, retryAfterMs };
+    } current.tokens -= cost; this.buckets.set(key, current); return { allowed: true, remaining: Math.floor(current.tokens), resetAt: now + Math.ceil(((this.capacity - current.tokens) / this.refillPerSecond) * 1000) }; }
+    clear(key) { if (key === undefined)
+        this.buckets.clear();
+    else
+        this.buckets.delete(key); }
+}
+exports.TokenBucketLimiter = TokenBucketLimiter;

package/dist-cjs/src/cli.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const promises_1 = require("node:fs/promises");
+const node_child_process_1 = require("node:child_process");
+const handler_js_1 = require("./webhook/handler.js");
+const bot_js_1 = require("./core/bot.js");
+async function commandDoctor() {
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    console.log(JSON.stringify({ node: process.version, tokenPresent: Boolean(token), cwd: process.cwd(), package: "@xbibzlibrary/telebibz" }, null, 2));
+    if (token) {
+        const bot = new bot_js_1.Bot(token);
+        const health = await bot.health();
+        console.log(JSON.stringify(health, null, 2));
+        if (!health.apiReachable)
+            process.exitCode = 1;
+    }
+}
+async function commandInit(name) { const dir = name || "my-telebibz-bot"; await (0, promises_1.mkdir)(dir, { recursive: true }); await (0, promises_1.writeFile)(`${dir}/index.ts`, `import { Bot } from "@xbibzlibrary/telebibz";\n\nconst bot = new Bot(process.env.TELEGRAM_BOT_TOKEN!);\nbot.command("start", (ctx) => ctx.reply("Hello from telebibz"));\nawait bot.start();\n`); await (0, promises_1.writeFile)(`${dir}/.env.example`, "TELEGRAM_BOT_TOKEN=\n"); console.log(`Created ${dir}`); }
+async function run(name, args) { return new Promise((resolve) => { const child = (0, node_child_process_1.spawn)(name, args, { stdio: "inherit", shell: false }); child.on("exit", (code, signal) => resolve(signal ? 1 : code ?? 1)); }); }
+async function main(argv = process.argv.slice(2)) {
+    const [command, argument] = argv;
+    switch (command) {
+        case "doctor":
+            await commandDoctor();
+            break;
+        case "init":
+            await commandInit(argument ?? "my-telebibz-bot");
+            break;
+        case "generate":
+            await run("node", ["scripts/generate-api.mjs"]);
+            break;
+        case "build":
+            process.exitCode = await run("npm", ["run", "build"]);
+            break;
+        case "test":
+            process.exitCode = await run("npm", ["test"]);
+            break;
+        case "webhook": {
+            const token = process.env.TELEGRAM_BOT_TOKEN;
+            if (!token)
+                throw new Error("TELEGRAM_BOT_TOKEN is required");
+            const bot = new bot_js_1.Bot(token);
+            const webhookOptions = process.env.TELEGRAM_WEBHOOK_SECRET ? { secretToken: process.env.TELEGRAM_WEBHOOK_SECRET } : {};
+            const handler = (0, handler_js_1.createWebhookHandler)(bot, webhookOptions);
+            await (0, promises_1.access)(".");
+            console.log(`Webhook handler ready: ${typeof handler}`);
+            break;
+        }
+        case "inspect":
+            console.log(JSON.stringify({ cwd: process.cwd(), node: process.version }, null, 2));
+            break;
+        default: console.log("telebibz commands: init, dev, generate, webhook, doctor, test, inspect, build");
+    }
+}
+if (process.argv[1]?.endsWith("/cli.js"))
+    void main().catch((error) => { console.error(error); process.exitCode = 1; });

package/dist-cjs/src/context/context.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+class Context {
+    update;
+    api;
+    session;
+    state = Object.create(null);
+    services;
+    params = Object.create(null);
+    constructor(options) {
+        this.update = options.update;
+        this.api = options.api;
+        this.session = options.session;
+        this.services = options.services;
+    }
+    get message() { return this.update.message ?? this.update.edited_message ?? this.update.channel_post ?? this.update.edited_channel_post ?? this.update.business_message ?? this.update.edited_business_message ?? this.update.guest_message; }
+    get chat() { return this.message?.chat; }
+    get from() { return this.message?.from ?? this.callbackQuery?.from ?? this.inlineQuery?.from; }
+    get sender() { return this.from; }
+    get callbackQuery() { return this.update.callback_query; }
+    get inlineQuery() { return this.update.inline_query; }
+    get poll() { return this.update.poll; }
+    get pollAnswer() { return this.update.poll_answer; }
+    get chatMember() { return this.update.chat_member; }
+    get myChatMember() { return this.update.my_chat_member; }
+    get chatJoinRequest() { return this.update.chat_join_request; }
+    get reaction() { return this.update.message_reaction; }
+    get boost() { return this.update.chat_boost ?? this.update.removed_chat_boost; }
+    async reply(text, extra = {}) {
+        if (!this.chat)
+            throw new Error("Cannot reply without a chat in this update.");
+        return this.api.methods.sendMessage({ chat_id: this.chat.id, text, reply_parameters: { message_id: this.message?.message_id }, ...extra });
+    }
+    async send(text, extra = {}) {
+        if (!this.chat)
+            throw new Error("Cannot send without a chat in this update.");
+        return this.api.methods.sendMessage({ chat_id: this.chat.id, text, ...extra });
+    }
+    async edit(text, extra = {}) {
+        if (!this.chat || !this.message)
+            throw new Error("Cannot edit without a chat and message in this update.");
+        return this.api.methods.editMessageText({ chat_id: this.chat.id, message_id: this.message.message_id, text, ...extra });
+    }
+    async delete() {
+        if (!this.chat || !this.message)
+            throw new Error("Cannot delete without a chat and message in this update.");
+        return this.api.methods.deleteMessage({ chat_id: this.chat.id, message_id: this.message.message_id });
+    }
+    async copy(fromChatId, messageId, extra = {}) { return this.api.call("copyMessage", { chat_id: this.chat?.id, from_chat_id: fromChatId, message_id: messageId, ...extra }); }
+    async forward(fromChatId, messageId, extra = {}) { return this.api.call("forwardMessage", { chat_id: this.chat?.id, from_chat_id: fromChatId, message_id: messageId, ...extra }); }
+    async pin(messageId = this.message?.message_id, extra = {}) { return this.api.call("pinChatMessage", { chat_id: this.chat?.id, message_id: messageId, ...extra }); }
+    async unpin(messageId = this.message?.message_id, extra = {}) { return this.api.call("unpinChatMessage", { chat_id: this.chat?.id, message_id: messageId, ...extra }); }
+    async react(reaction, extra = {}) { return this.api.call("setMessageReaction", { chat_id: this.chat?.id, message_id: this.message?.message_id, reaction, ...extra }); }
+    async answerCallbackQuery(text, extra = {}) { if (!this.callbackQuery)
+        throw new Error("No callback query in this update."); return this.api.methods.answerCallbackQuery({ callback_query_id: this.callbackQuery.id, text, ...extra }); }
+    async answerInlineQuery(results, extra = {}) { if (!this.inlineQuery)
+        throw new Error("No inline query in this update."); return this.api.call("answerInlineQuery", { inline_query_id: this.inlineQuery.id, results, ...extra }); }
+    async getChat() { if (!this.chat)
+        throw new Error("No chat in this update."); return this.api.methods.getChat({ chat_id: this.chat.id }); }
+    async getUserProfilePhotos(userId = this.from?.id, extra = {}) { if (!userId)
+        throw new Error("No user in this update."); return this.api.call("getUserProfilePhotos", { user_id: userId, ...extra }); }
+    async getFile(fileId) { return this.api.methods.getFile({ file_id: fileId }); }
+    withReplyMarkup(markup) { this.state.reply_markup = markup; return this; }
+}
+exports.Context = Context;

package/dist-cjs/src/core/bot.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bot = void 0;
+const client_js_1 = require("../api/client.js");
+const transport_js_1 = require("../api/transport.js");
+const context_js_1 = require("../context/context.js");
+const compose_js_1 = require("../middleware/compose.js");
+const router_js_1 = require("../router/router.js");
+const events_js_1 = require("./events.js");
+const storage_js_1 = require("../storage/storage.js");
+const plugin_js_1 = require("../plugins/plugin.js");
+const approval_js_1 = require("../approval/approval.js");
+class Bot {
+    api;
+    router = new router_js_1.Router();
+    events = new events_js_1.EventBus();
+    plugins;
+    session;
+    services;
+    approval;
+    token;
+    middlewares = [];
+    pollingOptions;
+    statusValue = "created";
+    pollingAbort;
+    offset = 0;
+    me;
+    constructor(options) {
+        const config = typeof options === "string" ? { token: options } : options;
+        if (!config.token || !/^\d+:[\w-]+$/.test(config.token))
+            throw new Error("A valid Telegram bot token is required.");
+        this.token = config.token;
+        this.session = config.session ?? new storage_js_1.MemoryStorage();
+        this.services = { ...(config.services ?? {}) };
+        const transport = config.transport ?? new transport_js_1.FetchTransport({ baseUrl: `${config.apiBaseUrl ?? "https://api.telegram.org"}/bot${config.token}`, ...(config.transportOptions ?? {}) });
+        this.api = new client_js_1.ApiClient({
+            transport,
+            hooks: {
+                onRequest: (context) => this.events.emit("api:request", { method: context.method, payload: context.payload }),
+                onResponse: (context) => this.events.emit("api:response", { method: context.method, durationMs: context.durationMs ?? 0, response: context.response }),
+                onError: (context) => this.events.emit("api:error", { method: context.method, durationMs: context.durationMs ?? 0, error: context.error }),
+            },
+        });
+        this.plugins = new plugin_js_1.PluginManager(this);
+        this.approval = config.approval ? new approval_js_1.ApprovalGate(this.api, config.approval) : undefined;
+        this.pollingOptions = {
+            timeout: config.polling?.timeout ?? 30,
+            limit: config.polling?.limit ?? 100,
+            allowedUpdates: config.polling?.allowedUpdates ?? [],
+            retryDelayMs: config.polling?.retryDelayMs ?? 500,
+            maxRetryDelayMs: config.polling?.maxRetryDelayMs ?? 30_000,
+        };
+        void this.events.emit("bot:created", { bot: this });
+    }
+    get status() { return this.statusValue; }
+    get botInfo() { return this.me; }
+    use(...middleware) { this.middlewares.push(...middleware); return this; }
+    command(name, handler) { this.router.command(name, handler); return this; }
+    callback(pattern, handler) { this.router.callback(pattern, handler); return this; }
+    onText(text, handler) { this.router.text(text, handler); return this; }
+    onRegex(expression, handler) { this.router.regex(expression, handler); return this; }
+    usePlugin(plugin) { this.plugins.use(plugin); return this; }
+    async init() {
+        if (this.statusValue === "initialized" || this.statusValue === "running")
+            return this;
+        this.me = await this.api.methods.getMe();
+        if (this.approval) {
+            const approval = await this.approval.check({ bot: this.me });
+            if (!approval.allowed) {
+                this.statusValue = "awaiting-approval";
+                return this;
+            }
+        }
+        this.statusValue = "initialized";
+        await this.events.emit("bot:initialized", { bot: this });
+        await this.plugins.setup();
+        await this.plugins.start();
+        return this;
+    }
+    async start() { await this.launch({ mode: "polling" }); }
+    async launch(options = { mode: "polling" }) {
+        if (options.mode !== "polling")
+            throw new Error("Use createWebhookHandler() for webhook mode.");
+        await this.init();
+        if (this.statusValue === "running")
+            return;
+        this.statusValue = "starting";
+        await this.events.emit("bot:starting", { bot: this });
+        this.pollingAbort = new AbortController();
+        this.statusValue = "running";
+        await this.events.emit("bot:started", { bot: this });
+        await this.poll(options.timeout ?? this.pollingOptions.timeout, options.allowedUpdates ?? this.pollingOptions.allowedUpdates, this.pollingAbort.signal);
+    }
+    async stop() {
+        if (this.statusValue === "stopped" || this.statusValue === "created")
+            return;
+        this.statusValue = "stopping";
+        await this.events.emit("bot:stopping", { bot: this });
+        this.pollingAbort?.abort();
+        this.pollingAbort = undefined;
+        await this.plugins.dispose();
+        this.statusValue = "stopped";
+        await this.events.emit("bot:stopped", { bot: this });
+    }
+    async restart() { await this.stop(); await this.start(); }
+    async health() {
+        try {
+            const bot = await this.api.methods.getMe();
+            return { status: this.statusValue, apiReachable: true, bot, checkedAt: new Date().toISOString() };
+        }
+        catch (error) {
+            return { status: this.statusValue, apiReachable: false, checkedAt: new Date().toISOString(), error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async getMe() { const me = await this.api.methods.getMe(); this.me = me; return me; }
+    async setCommands(commands, scope, languageCode) { return this.api.call("setMyCommands", { commands, scope, language_code: languageCode }); }
+    async deleteCommands(scope, languageCode) { return this.api.call("deleteMyCommands", { scope, language_code: languageCode }); }
+    async handleUpdate(update) {
+        const message = update.message ?? update.edited_message ?? update.channel_post ?? update.edited_channel_post ?? update.business_message ?? update.guest_message;
+        const key = message?.chat?.id !== undefined ? `${message.chat.id}:${message.from?.id ?? "anonymous"}` : `update:${update.update_id}`;
+        const session = await this.session.get(key) ?? {};
+        if (this.approval && this.me && !(await this.approval.isAllowed(this.me.id))) {
+            if (update.callback_query)
+                await this.approval.handleCallback(update.callback_query);
+            return;
+        }
+        const ctx = new context_js_1.Context({ update, api: this.api, session, services: this.services });
+        await this.events.emit("update", { update });
+        if (message)
+            await this.events.emit("message", { message });
+        const pipeline = (0, compose_js_1.compose)([...this.middlewares, async (context) => this.router.handle(context)]);
+        try {
+            await pipeline(ctx);
+            await this.session.set(key, ctx.session);
+        }
+        catch (error) {
+            this.statusValue = "error";
+            await this.events.emit("bot:error", { bot: this, error });
+            throw error;
+        }
+    }
+    async poll(timeout, allowedUpdates, signal) {
+        let delay = this.pollingOptions.retryDelayMs;
+        while (!signal.aborted) {
+            try {
+                const updates = await this.api.methods.getUpdates({ offset: this.offset, limit: this.pollingOptions.limit, timeout, allowed_updates: allowedUpdates });
+                delay = this.pollingOptions.retryDelayMs;
+                for (const update of updates) {
+                    this.offset = Math.max(this.offset, update.update_id + 1);
+                    await this.handleUpdate(update);
+                }
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                await this.events.emit("polling:reconnect", { error, attempt: Math.ceil(delay / this.pollingOptions.retryDelayMs) });
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                delay = Math.min(this.pollingOptions.maxRetryDelayMs, delay * 2);
+            }
+        }
+    }
+}
+exports.Bot = Bot;