@riseonly/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,616 @@
+import { createServer } from 'http';
+import { createHmac, timingSafeEqual } from 'crypto';
+
+// src/bot.ts
+
+// src/constants.ts
+var DEFAULT_API_BASE = "https://api.riseonly.net";
+var CANONICAL_API_PREFIX = "/api/bot/v1";
+var WEBHOOK_SECRET_HEADER = "x-riseonly-bot-api-secret-token";
+var IDEMPOTENCY_HEADER = "x-request-id";
+var SUPPORTED_METHODS = [
+  "getMe",
+  "sendMessage",
+  "sendPhoto",
+  "sendVideo",
+  "sendDocument",
+  "sendAudio",
+  "sendVoice",
+  "sendAnimation",
+  "editMessageText",
+  "deleteMessage",
+  "sendChatAction",
+  "getUpdates",
+  "setWebhook",
+  "deleteWebhook",
+  "getWebhookInfo",
+  "setMyCommands",
+  "getMyCommands",
+  "deleteMyCommands",
+  "answerCallbackQuery",
+  "getChat"
+];
+var UPDATE_TYPES = [
+  "message",
+  "edited_message",
+  "callback_query",
+  "chat_member",
+  "my_chat_member"
+];
+var CHAT_ACTIONS = [
+  "typing",
+  "upload_photo",
+  "record_video",
+  "upload_video",
+  "record_voice",
+  "upload_voice",
+  "upload_document",
+  "choose_sticker",
+  "find_location",
+  "record_video_note",
+  "upload_video_note"
+];
+var COMMAND_SCOPES = [
+  "default",
+  "all_private_chats",
+  "all_group_chats",
+  "all_chat_administrators"
+];
+
+// src/errors.ts
+var RiseonlyError = class _RiseonlyError extends Error {
+  code;
+  retryAfter;
+  response;
+  constructor(message, code, retryAfter, response) {
+    super(message);
+    this.name = "RiseonlyError";
+    this.code = code;
+    this.retryAfter = retryAfter;
+    this.response = response;
+  }
+  static fromApiResponse(body) {
+    return new _RiseonlyError(
+      body.description,
+      body.error_code,
+      body.parameters?.retry_after,
+      body
+    );
+  }
+};
+var RiseonlyNetworkError = class extends RiseonlyError {
+  cause;
+  constructor(message, cause, code = 0) {
+    super(message, code);
+    this.name = "RiseonlyNetworkError";
+    this.cause = cause;
+  }
+};
+var RiseonlyTimeoutError = class extends RiseonlyNetworkError {
+  constructor(message = "Request timed out") {
+    super(message, void 0, 408);
+    this.name = "RiseonlyTimeoutError";
+  }
+};
+
+// src/client.ts
+var ApiClient = class {
+  token;
+  baseUrl;
+  fetchImpl;
+  requestTimeoutMs;
+  useCompatibleEndpoint;
+  constructor(token, options = {}) {
+    if (!token?.trim()) {
+      throw new Error("bot token is required");
+    }
+    this.token = token.trim();
+    this.baseUrl = (options.baseUrl ?? DEFAULT_API_BASE).replace(/\/$/, "");
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 6e4;
+    this.useCompatibleEndpoint = options.useCompatibleEndpoint ?? false;
+  }
+  /**
+   * Returns the platform capabilities document.
+   */
+  async getCapabilities(signal) {
+    const url = `${this.baseUrl}${CANONICAL_API_PREFIX}/capabilities`;
+    const response = await this.fetchImpl(url, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal
+    });
+    if (!response.ok) {
+      throw new RiseonlyNetworkError(`capabilities request failed with status ${response.status}`);
+    }
+    return response.json();
+  }
+  /**
+   * Calls a Bot API method and returns the typed result.
+   */
+  async callMethod(method, payload = {}, options = {}) {
+    const envelope = await this.request(method, payload, options);
+    return envelope.result;
+  }
+  /**
+   * Performs a raw Bot API request and returns the full envelope.
+   */
+  async request(method, payload = {}, options = {}) {
+    const url = this.buildMethodUrl(method);
+    const headers = {
+      Authorization: `Bot ${this.token}`,
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    if (options.requestId) {
+      headers[IDEMPOTENCY_HEADER] = options.requestId;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new RiseonlyTimeoutError();
+      }
+      throw new RiseonlyNetworkError("network request failed", error);
+    } finally {
+      clearTimeout(timeout);
+    }
+    const body = await response.json();
+    if (!body.ok) {
+      throw RiseonlyError.fromApiResponse(body);
+    }
+    return body;
+  }
+  async getMe(options) {
+    return this.callMethod("getMe", {}, options);
+  }
+  async sendMessage(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("sendMessage", payload, { requestId });
+  }
+  async sendPhoto(photo, options) {
+    return this.sendMedia("sendPhoto", "photo", photo, options);
+  }
+  async sendVideo(video, options) {
+    return this.sendMedia("sendVideo", "video", video, options);
+  }
+  async sendDocument(document, options) {
+    return this.sendMedia("sendDocument", "document", document, options);
+  }
+  async sendAudio(audio, options) {
+    return this.sendMedia("sendAudio", "audio", audio, options);
+  }
+  async sendVoice(voice, options) {
+    return this.sendMedia("sendVoice", "voice", voice, options);
+  }
+  async sendAnimation(animation, options) {
+    return this.sendMedia("sendAnimation", "animation", animation, options);
+  }
+  async editMessageText(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("editMessageText", payload, { requestId });
+  }
+  async deleteMessage(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("deleteMessage", payload, { requestId });
+  }
+  async sendChatAction(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("sendChatAction", payload, { requestId });
+  }
+  async getUpdates(options = {}) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("getUpdates", payload, { requestId });
+  }
+  async setWebhook(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("setWebhook", payload, { requestId });
+  }
+  async deleteWebhook(options = {}) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("deleteWebhook", payload, { requestId });
+  }
+  async getWebhookInfo(options) {
+    return this.callMethod("getWebhookInfo", {}, options);
+  }
+  async setMyCommands(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("setMyCommands", payload, { requestId });
+  }
+  async getMyCommands(options = {}) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("getMyCommands", payload, { requestId });
+  }
+  async deleteMyCommands(options = {}) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("deleteMyCommands", payload, { requestId });
+  }
+  async answerCallbackQuery(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("answerCallbackQuery", payload, { requestId });
+  }
+  async getChat(options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod("getChat", payload, { requestId });
+  }
+  async sendMedia(method, field, media, options) {
+    const { requestId, ...payload } = options;
+    return this.callMethod(
+      method,
+      {
+        ...payload,
+        [field]: this.normalizeMedia(media)
+      },
+      { requestId }
+    );
+  }
+  normalizeMedia(media) {
+    if (typeof media === "string") {
+      return media;
+    }
+    if (media.file_id) {
+      return media.file_id;
+    }
+    if (media.url) {
+      return media.url;
+    }
+    throw new Error("media requires file_id or url");
+  }
+  buildMethodUrl(method) {
+    if (this.useCompatibleEndpoint) {
+      return `${this.baseUrl}/bot${this.token}/${method}`;
+    }
+    return `${this.baseUrl}${CANONICAL_API_PREFIX}/${method}`;
+  }
+};
+
+// src/webhook.ts
+function parseWebhookUpdate(body) {
+  if (!body || typeof body !== "object") {
+    throw new Error("webhook body must be an object");
+  }
+  const update = body;
+  if (typeof update.update_id !== "number") {
+    throw new Error("webhook body is missing update_id");
+  }
+  return update;
+}
+function verifyWebhookSecret(headers, secretToken) {
+  if (!secretToken) {
+    return true;
+  }
+  const headerValue = headers[WEBHOOK_SECRET_HEADER] ?? headers[WEBHOOK_SECRET_HEADER.toLowerCase()];
+  if (!headerValue) {
+    return false;
+  }
+  const received = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+  return received === secretToken;
+}
+function createWebhookHandler(options) {
+  return async (request) => {
+    try {
+      if (!verifyWebhookSecret(request.headers, options.secretToken)) {
+        return { status: 401, body: { ok: false, description: "invalid webhook secret" } };
+      }
+      const update = parseWebhookUpdate(request.body);
+      await options.onUpdate(update);
+      return { status: 200, body: { ok: true } };
+    } catch (error) {
+      await options.onError?.(error);
+      return { status: 400, body: { ok: false, description: "invalid webhook payload" } };
+    }
+  };
+}
+
+// src/bot.ts
+var RiseonlyBot = class extends ApiClient {
+  listeners = {
+    message: [],
+    edited_message: [],
+    callback_query: [],
+    update: [],
+    polling_error: [],
+    error: []
+  };
+  pollingOptions;
+  webhookOptions;
+  polling = false;
+  pollingAbort;
+  offset = 0;
+  webhookServer;
+  constructor(token, options = {}) {
+    super(token, options);
+    this.pollingOptions = normalizePollingOptions(options.polling);
+    this.webhookOptions = options.webhook === false ? void 0 : options.webhook;
+    if (options.allowed_updates) {
+      this.pollingOptions.allowed_updates = options.allowed_updates;
+    }
+    if (this.pollingOptions.autoStart) {
+      void this.startPolling();
+    }
+  }
+  /**
+   * Registers an event listener.
+   */
+  on(event, handler) {
+    this.listeners[event].push(handler);
+    return this;
+  }
+  /**
+   * Removes a previously registered listener.
+   */
+  off(event, handler) {
+    const bucket = this.listeners[event];
+    const index = bucket.indexOf(handler);
+    if (index >= 0) {
+      bucket.splice(index, 1);
+    }
+    return this;
+  }
+  /**
+   * Registers a one-time event listener.
+   */
+  once(event, handler) {
+    const wrapper = ((...args) => {
+      this.off(event, wrapper);
+      return handler(...args);
+    });
+    return this.on(event, wrapper);
+  }
+  /**
+   * Starts long polling for bot updates.
+   */
+  async startPolling(options = {}) {
+    if (this.polling) {
+      return;
+    }
+    this.polling = true;
+    this.pollingOptions = { ...this.pollingOptions, ...options, autoStart: true };
+    this.pollingAbort = new AbortController();
+    void this.pollLoop();
+  }
+  /**
+   * Stops long polling.
+   */
+  async stopPolling() {
+    this.polling = false;
+    this.pollingAbort?.abort();
+    this.pollingAbort = void 0;
+  }
+  /**
+   * Starts a built-in HTTP server that receives webhook updates.
+   */
+  async startWebhook(options = {}) {
+    const config = { ...this.webhookOptions, ...options };
+    this.webhookOptions = config;
+    const path = config.path ?? "/";
+    const host = config.host ?? "0.0.0.0";
+    const port = config.port ?? 3e3;
+    const handler = createWebhookHandler({
+      secretToken: config.secretToken,
+      onUpdate: (update) => this.processUpdate(update),
+      onError: (error) => this.emit("error", error)
+    });
+    if (this.webhookServer) {
+      return;
+    }
+    this.webhookServer = createServer(async (req, res) => {
+      if (req.method !== "POST" || req.url?.split("?")[0] !== path) {
+        respond(res, 404, { ok: false });
+        return;
+      }
+      try {
+        const body = await readJsonBody(req);
+        const result = await handler({
+          headers: normalizeHeaders(req.headers),
+          body
+        });
+        respond(res, result.status, result.body);
+      } catch (error) {
+        await this.emit("error", error);
+        respond(res, 500, { ok: false });
+      }
+    });
+    await new Promise((resolve, reject) => {
+      this.webhookServer.once("error", reject);
+      this.webhookServer.listen(port, host, () => resolve());
+    });
+  }
+  /**
+   * Stops the built-in webhook server.
+   */
+  async stopWebhook() {
+    if (!this.webhookServer) {
+      return;
+    }
+    const server = this.webhookServer;
+    this.webhookServer = void 0;
+    await new Promise((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    });
+  }
+  /**
+   * Processes a single update and dispatches events.
+   */
+  async processUpdate(update) {
+    await this.emit("update", update);
+    if (update.message) {
+      await this.emit("message", update.message, update);
+    }
+    if (update.edited_message) {
+      await this.emit("edited_message", update.edited_message, update);
+    }
+    if (update.callback_query) {
+      await this.emit("callback_query", update.callback_query, update);
+    }
+  }
+  /**
+   * Sends a text message to a chat.
+   */
+  async reply(message, text, extra = {}) {
+    return this.sendMessage({
+      chat_id: message.chat.id,
+      text,
+      reply_to_message_id: message.message_id,
+      ...extra
+    });
+  }
+  /**
+   * Answers a callback query and optionally sends a toast.
+   */
+  async answer(query, text, showAlert = false) {
+    return this.answerCallbackQuery({
+      callback_query_id: query.id,
+      text,
+      show_alert: showAlert
+    });
+  }
+  async pollLoop() {
+    while (this.polling) {
+      try {
+        const updates = await this.getUpdates({
+          offset: this.offset,
+          timeout: this.pollingOptions.timeout,
+          limit: this.pollingOptions.limit,
+          allowed_updates: this.pollingOptions.allowed_updates,
+          signal: this.pollingAbort?.signal
+        });
+        let processed = 0;
+        for (const update of updates) {
+          if (update.update_id < this.offset) {
+            continue;
+          }
+          this.offset = Math.max(this.offset, update.update_id + 1);
+          await this.processUpdate(update);
+          processed += 1;
+        }
+        if (processed === 0) {
+          await sleep(this.pollingOptions.interval ?? 1e3);
+        }
+      } catch (error) {
+        if (!this.polling || isAbortError(error)) {
+          return;
+        }
+        await this.emit("polling_error", error);
+        if (error instanceof RiseonlyError && error.retryAfter) {
+          await sleep(error.retryAfter * 1e3);
+        } else {
+          await sleep(this.pollingOptions.interval ?? 1e3);
+        }
+      }
+    }
+  }
+  async emit(event, ...args) {
+    for (const listener of [...this.listeners[event]]) {
+      try {
+        await listener(...args);
+      } catch (error) {
+        await this.emit("error", error);
+      }
+    }
+  }
+};
+function normalizePollingOptions(value) {
+  if (!value) {
+    return { interval: 1e3, timeout: 30, limit: 100, autoStart: false };
+  }
+  if (value === true) {
+    return { interval: 1e3, timeout: 30, limit: 100, autoStart: true };
+  }
+  return {
+    interval: 1e3,
+    timeout: 30,
+    limit: 100,
+    autoStart: true,
+    ...value
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function normalizeHeaders(headers) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    normalized[key] = value;
+  }
+  return normalized;
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    return {};
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function respond(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  res.end(body === void 0 ? void 0 : JSON.stringify(body));
+}
+var INIT_DATA_HASH_RE = /^[0-9a-f]{64}$/;
+function parseInitData(encoded) {
+  const fields = Object.fromEntries(new URLSearchParams(encoded).entries());
+  return fields;
+}
+function buildInitDataCheckString(fields) {
+  return Object.entries(fields).filter(([key]) => key !== "hash").sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`).join("\n");
+}
+function deriveInitDataSecret(botToken) {
+  return createHmac("sha256", "WebAppData").update(botToken).digest();
+}
+function signInitData(botToken, dataCheckString) {
+  const secret = deriveInitDataSecret(botToken);
+  return createHmac("sha256", secret).update(dataCheckString).digest("hex");
+}
+function verifyInitData(botToken, encoded) {
+  const fields = parseInitData(encoded);
+  const hash = fields.hash;
+  if (!hash) {
+    throw new Error("init data hash is missing");
+  }
+  if (!INIT_DATA_HASH_RE.test(hash)) {
+    throw new Error("init data signature is invalid");
+  }
+  const dataCheckString = buildInitDataCheckString(fields);
+  const expected = signInitData(botToken, dataCheckString);
+  const left = Buffer.from(hash, "hex");
+  const right = Buffer.from(expected, "hex");
+  if (left.length !== right.length || !timingSafeEqual(left, right)) {
+    throw new Error("init data signature is invalid");
+  }
+  const expiresAt = fields.expires_at ? Number(fields.expires_at) : void 0;
+  if (expiresAt !== void 0 && Number.isFinite(expiresAt) && expiresAt < Date.now()) {
+    throw new Error("init data has expired");
+  }
+  return fields;
+}
+function extractInitDataFromLaunchUrl(launchUrl) {
+  const url = new URL(launchUrl);
+  const hash = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
+  if (!hash) {
+    return null;
+  }
+  return new URLSearchParams(hash).get("riseonlyInitData");
+}
+function createRequestId() {
+  return crypto.randomUUID();
+}
+
+export { ApiClient, CANONICAL_API_PREFIX, CHAT_ACTIONS, COMMAND_SCOPES, DEFAULT_API_BASE, IDEMPOTENCY_HEADER, RiseonlyBot, RiseonlyError, RiseonlyNetworkError, RiseonlyTimeoutError, SUPPORTED_METHODS, UPDATE_TYPES, WEBHOOK_SECRET_HEADER, buildInitDataCheckString, createRequestId, createWebhookHandler, deriveInitDataSecret, extractInitDataFromLaunchUrl, parseInitData, parseWebhookUpdate, signInitData, verifyInitData, verifyWebhookSecret };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map