@mtcute/bun 0.16.7 → 0.16.14

package/chunks/es/BmtxbrWZ.js

@@ -0,0 +1,29 @@
+import { unlinkSync } from "node:fs";
+import { FileLocation } from "@mtcute/core";
+import { downloadAsIterable, downloadAsStream } from "@mtcute/core/methods.js";
+import { Readable } from "node:stream";
+async function downloadToFile(client, filename, location, params) {
+  if (location instanceof FileLocation && ArrayBuffer.isView(location.location)) {
+    await Bun.write(filename, location.location);
+  }
+  const output = Bun.file(filename).writer();
+  if (params?.abortSignal) {
+    params.abortSignal.addEventListener("abort", () => {
+      client.log.debug("aborting file download %s - cleaning up", filename);
+      Promise.resolve(output.end()).catch(() => {
+      });
+      unlinkSync(filename);
+    });
+  }
+  for await (const chunk of downloadAsIterable(client, location, params)) {
+    output.write(chunk);
+  }
+  await output.end();
+}
+function downloadAsNodeStream(client, location, params) {
+  return Readable.fromWeb(downloadAsStream(client, location, params));
+}
+export {
+  downloadAsNodeStream,
+  downloadToFile
+};

package/client.d.ts

@@ -1,7 +1,6 @@
-import type { Readable } from 'node:stream';
-import type { FileDownloadLocation, FileDownloadParameters, ITelegramStorageProvider, PartialOnly, User } from '@mtcute/core';
-import type { BaseTelegramClientOptions as BaseTelegramClientOptionsBase, TelegramClientOptions } from '@mtcute/core/client.js';
-import { BaseTelegramClient as BaseTelegramClientBase, TelegramClient as TelegramClientBase } from '@mtcute/core/client.js';
+import { Readable } from 'node:stream';
+import { FileDownloadLocation, FileDownloadParameters, ITelegramStorageProvider, PartialOnly, User } from '@mtcute/core';
+import { BaseTelegramClientOptions as BaseTelegramClientOptionsBase, TelegramClientOptions, BaseTelegramClient as BaseTelegramClientBase, TelegramClient as TelegramClientBase } from '@mtcute/core/client.js';
 export type { TelegramClientOptions };
 export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegramClientOptionsBase, 'storage'>, 'transport' | 'crypto'> {
     /**

package/common-internals-node/platform.d.ts

@@ -1,4 +1,4 @@
-import type { ICorePlatform } from '@mtcute/core/platform.js';
+import { ICorePlatform } from '@mtcute/core/platform.js';
 import { normalizeFile } from '../utils/normalize-file.js';
 import { beforeExit } from './exit-hook.js';
 import { defaultLoggingHandler } from './logging.js';

package/index.d.cts

@@ -0,0 +1,9 @@
+export * from './client.js';
+export * from './platform.js';
+export * from './sqlite/index.js';
+export * from './utils/crypto.js';
+export * from './utils/tcp.js';
+export * from './worker.js';
+export * from '@mtcute/core';
+export * from '@mtcute/html-parser';
+export * from '@mtcute/markdown-parser';

package/index.js

@@ -1,10 +1,541 @@
-export * from './client.js';
-export * from './platform.js';
-export * from './sqlite/index.js';
-export * from './utils/crypto.js';
-export * from './utils/tcp.js';
-export * from './worker.js';
-export * from '@mtcute/core';
-export * from '@mtcute/html-parser';
-export * from '@mtcute/markdown-parser';
-//# sourceMappingURL=index.js.map
+import { createInterface } from "node:readline";
+import { BaseTelegramClient as BaseTelegramClient$1, TelegramClient as TelegramClient$1 } from "@mtcute/core/client.js";
+import { setPlatform } from "@mtcute/core/platform.js";
+import { downloadToFile, downloadAsNodeStream } from "./chunks/es/BmtxbrWZ.js";
+import * as os from "node:os";
+import { createReadStream, ReadStream } from "node:fs";
+import { stat, readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { Readable } from "node:stream";
+import { BaseSqliteStorageDriver, BaseSqliteStorage, TransportState, MtcuteError, IntermediatePacketCodec } from "@mtcute/core";
+export * from "@mtcute/core";
+import { Database } from "bun:sqlite";
+import { deflateSync, gunzipSync } from "node:zlib";
+import { pbkdf2 } from "node:crypto";
+import { BaseCryptoProvider } from "@mtcute/core/utils.js";
+import { initSync, ige256Encrypt, ige256Decrypt, createCtr256, ctr256, freeCtr256 } from "@mtcute/wasm";
+import EventEmitter from "events";
+import { parentPort, Worker } from "node:worker_threads";
+import { TelegramWorker as TelegramWorker$1, TelegramWorkerPort as TelegramWorkerPort$1 } from "@mtcute/core/worker.js";
+export * from "@mtcute/html-parser";
+export * from "@mtcute/markdown-parser";
+function nodeStreamToWeb(stream) {
+  if (typeof Readable.toWeb === "function") {
+    return Readable.toWeb(stream);
+  }
+  stream.pause();
+  return new ReadableStream({
+    start(c) {
+      stream.on("data", (chunk) => {
+        c.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        c.close();
+      });
+      stream.on("error", (err) => {
+        c.error(err);
+      });
+    },
+    pull() {
+      stream.resume();
+    }
+  });
+}
+async function normalizeFile$1(file) {
+  if (typeof file === "string") {
+    file = createReadStream(file);
+  }
+  if (file instanceof ReadStream) {
+    const fileName = basename(file.path.toString());
+    const fileSize = await stat(file.path.toString()).then((stat2) => stat2.size);
+    return {
+      file: nodeStreamToWeb(file),
+      fileName,
+      fileSize
+    };
+  }
+  if (file instanceof Readable) {
+    return {
+      file: nodeStreamToWeb(file)
+    };
+  }
+  return null;
+}
+let installed = false;
+let handled = false;
+const callbacks = /* @__PURE__ */ new Set();
+const myHandlers = /* @__PURE__ */ new Map();
+function register(shouldManuallyExit, signal, event) {
+  function eventHandler() {
+    if (handled) {
+      return;
+    }
+    handled = true;
+    for (const callback of callbacks) {
+      callback();
+    }
+    for (const [event2, handler] of myHandlers) {
+      process.off(event2, handler);
+    }
+    if (shouldManuallyExit) {
+      process.kill(process.pid, signal);
+    }
+  }
+  process.on(event, eventHandler);
+  myHandlers.set(event, eventHandler);
+}
+function beforeExit(fn) {
+  if (typeof process === "undefined") return () => {
+  };
+  if (!installed) {
+    installed = true;
+    register(true, 0, "beforeExit");
+    register(true, 2, "SIGINT");
+    register(true, 15, "SIGTERM");
+    register(false, 15, "exit");
+  }
+  callbacks.add(fn);
+  return () => {
+    callbacks.delete(fn);
+  };
+}
+const isTty = typeof process === "object" && Boolean(process.stdout?.isTTY);
+const BASE_FORMAT = isTty ? "%s [%s] [%s%s\x1B[0m] " : "%s [%s] [%s] ";
+const LEVEL_NAMES = isTty ? [
+  "",
+  // OFF
+  "\x1B[31mERR\x1B[0m",
+  "\x1B[33mWRN\x1B[0m",
+  "\x1B[34mINF\x1B[0m",
+  "\x1B[36mDBG\x1B[0m",
+  "\x1B[35mVRB\x1B[0m"
+] : [
+  "",
+  // OFF
+  "ERR",
+  "WRN",
+  "INF",
+  "DBG",
+  "VRB"
+];
+const TAG_COLORS = [6, 2, 3, 4, 5, 1].map((i) => `\x1B[3${i};1m`);
+const defaultLoggingHandler = isTty ? (color, level, tag, fmt, args) => {
+  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], TAG_COLORS[color], tag, ...args);
+} : (color, level, tag, fmt, args) => {
+  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], tag, ...args);
+};
+const BUFFER_BASE64_URL_AVAILABLE = typeof Buffer.isEncoding === "function" && Buffer.isEncoding("base64url");
+const toBuffer = (buf) => Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+class NodePlatform {
+  getDeviceModel() {
+    return `Node.js/${process.version} (${os.type()} ${os.arch()})`;
+  }
+  getDefaultLogLevel() {
+    const envLogLevel = Number.parseInt(process.env.MTCUTE_LOG_LEVEL ?? "");
+    if (!Number.isNaN(envLogLevel)) {
+      return envLogLevel;
+    }
+    return null;
+  }
+  // ITlPlatform
+  utf8ByteLength(str) {
+    return Buffer.byteLength(str, "utf8");
+  }
+  utf8Encode(str) {
+    return Buffer.from(str, "utf8");
+  }
+  utf8Decode(buf) {
+    return toBuffer(buf).toString("utf8");
+  }
+  hexEncode(buf) {
+    return toBuffer(buf).toString("hex");
+  }
+  hexDecode(str) {
+    return Buffer.from(str, "hex");
+  }
+  base64Encode(buf, url = false) {
+    const nodeBuffer = toBuffer(buf);
+    if (url && BUFFER_BASE64_URL_AVAILABLE) return nodeBuffer.toString("base64url");
+    const str = nodeBuffer.toString("base64");
+    if (url) return str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    return str;
+  }
+  base64Decode(string, url = false) {
+    if (url && BUFFER_BASE64_URL_AVAILABLE) {
+      return Buffer.from(string, "base64url");
+    }
+    if (url) {
+      string = string.replace(/-/g, "+").replace(/_/g, "/");
+      while (string.length % 4) string += "=";
+    }
+    return Buffer.from(string, "base64");
+  }
+}
+NodePlatform.prototype.log = defaultLoggingHandler;
+NodePlatform.prototype.beforeExit = beforeExit;
+NodePlatform.prototype.normalizeFile = normalizeFile$1;
+function isBunFile(file) {
+  return file instanceof Blob && "name" in file && file.name.length > 0;
+}
+async function normalizeFile(file) {
+  if (typeof file === "string") {
+    file = Bun.file(file);
+  }
+  if (isBunFile(file)) {
+    return {
+      file,
+      fileName: file.name,
+      fileSize: file.size
+    };
+  }
+  if (file instanceof ReadStream) {
+    const fileName = basename(file.path.toString());
+    const fileSize = await stat(file.path.toString()).then((stat2) => stat2.size);
+    return {
+      file: Readable.toWeb(file),
+      fileName,
+      fileSize
+    };
+  }
+  if (file instanceof Readable) {
+    return {
+      file: Readable.toWeb(file)
+    };
+  }
+  return null;
+}
+class BunPlatform extends NodePlatform {
+  getDeviceModel() {
+    return `Bun/${Bun.version} (${os.type()} ${os.arch()})`;
+  }
+}
+BunPlatform.prototype.normalizeFile = normalizeFile;
+class SqliteStorageDriver extends BaseSqliteStorageDriver {
+  constructor(filename = ":memory:", params) {
+    super();
+    this.filename = filename;
+    this.params = params;
+  }
+  _createDatabase() {
+    const db = new Database(this.filename);
+    if (!this.params?.disableWal) {
+      db.exec("PRAGMA journal_mode = WAL;");
+    }
+    return db;
+  }
+}
+class SqliteStorage extends BaseSqliteStorage {
+  constructor(filename = ":memory:", params) {
+    super(new SqliteStorageDriver(filename, params));
+    this.filename = filename;
+    this.params = params;
+  }
+}
+class BunCryptoProvider extends BaseCryptoProvider {
+  async initialize() {
+    const wasmFile = require.resolve("@mtcute/wasm/mtcute.wasm");
+    const wasm = await readFile(wasmFile);
+    initSync(wasm);
+  }
+  createAesIge(key, iv) {
+    return {
+      encrypt(data) {
+        return ige256Encrypt(data, key, iv);
+      },
+      decrypt(data) {
+        return ige256Decrypt(data, key, iv);
+      }
+    };
+  }
+  createAesCtr(key, iv) {
+    const ctx = createCtr256(key, iv);
+    return {
+      process: (data) => ctr256(ctx, data),
+      close: () => freeCtr256(ctx)
+    };
+  }
+  pbkdf2(password, salt, iterations, keylen = 64, algo = "sha512") {
+    return new Promise(
+      (resolve, reject) => pbkdf2(password, salt, iterations, keylen, algo, (err, buf) => err !== null ? reject(err) : resolve(buf))
+    );
+  }
+  sha1(data) {
+    const res = new Uint8Array(Bun.SHA1.byteLength);
+    Bun.SHA1.hash(data, res);
+    return res;
+  }
+  sha256(data) {
+    const res = new Uint8Array(Bun.SHA256.byteLength);
+    Bun.SHA256.hash(data, res);
+    return res;
+  }
+  async hmacSha256(data, key) {
+    const keyMaterial = await crypto.subtle.importKey(
+      "raw",
+      key,
+      { name: "HMAC", hash: { name: "SHA-256" } },
+      false,
+      ["sign"]
+    );
+    const res = await crypto.subtle.sign({ name: "HMAC" }, keyMaterial, data);
+    return new Uint8Array(res);
+  }
+  gzip(data, maxSize) {
+    try {
+      return deflateSync(data, {
+        maxOutputLength: maxSize
+      });
+    } catch (e) {
+      if (e.code === "ERR_BUFFER_TOO_LARGE") {
+        return null;
+      }
+      throw e;
+    }
+  }
+  gunzip(data) {
+    return gunzipSync(data);
+  }
+  randomFill(buf) {
+    crypto.getRandomValues(buf);
+  }
+}
+class BaseTcpTransport extends EventEmitter {
+  _currentDc = null;
+  _state = TransportState.Idle;
+  _socket = null;
+  _crypto;
+  log;
+  packetCodecInitialized = false;
+  _updateLogPrefix() {
+    if (this._currentDc) {
+      this.log.prefix = `[TCP:${this._currentDc.ipAddress}:${this._currentDc.port}] `;
+    } else {
+      this.log.prefix = "[TCP:disconnected] ";
+    }
+  }
+  setup(crypto2, log) {
+    this._crypto = crypto2;
+    this.log = log.create("tcp");
+    this._updateLogPrefix();
+  }
+  state() {
+    return this._state;
+  }
+  currentDc() {
+    return this._currentDc;
+  }
+  // eslint-disable-next-line unused-imports/no-unused-vars
+  connect(dc, testMode) {
+    if (this._state !== TransportState.Idle) {
+      throw new MtcuteError("Transport is not IDLE");
+    }
+    if (!this.packetCodecInitialized) {
+      this._packetCodec.setup?.(this._crypto, this.log);
+      this._packetCodec.on("error", (err) => this.emit("error", err));
+      this._packetCodec.on("packet", (buf) => this.emit("message", buf));
+      this.packetCodecInitialized = true;
+    }
+    this._state = TransportState.Connecting;
+    this._currentDc = dc;
+    this._updateLogPrefix();
+    this.log.debug("connecting to %j", dc);
+    Bun.connect({
+      hostname: dc.ipAddress,
+      port: dc.port,
+      socket: {
+        open: this.handleConnect.bind(this),
+        error: this.handleError.bind(this),
+        data: (socket, data) => this._packetCodec.feed(data),
+        close: this.close.bind(this),
+        drain: this.handleDrained.bind(this)
+      }
+    }).catch((err) => {
+      this.handleError(null, err);
+      this.close();
+    });
+  }
+  close() {
+    if (this._state === TransportState.Idle) return;
+    this.log.info("connection closed");
+    this._state = TransportState.Idle;
+    this._socket?.end();
+    this._socket = null;
+    this._currentDc = null;
+    this._packetCodec.reset();
+    this._sendOnceDrained = [];
+    this.emit("close");
+  }
+  handleError(socket, error) {
+    this.log.error("error: %s", error.stack);
+    if (this.listenerCount("error") > 0) {
+      this.emit("error", error);
+    }
+  }
+  handleConnect(socket) {
+    this._socket = socket;
+    this.log.info("connected");
+    Promise.resolve(this._packetCodec.tag()).then((initialMessage) => {
+      if (initialMessage.length) {
+        this._socket.write(initialMessage);
+        this._state = TransportState.Ready;
+        this.emit("ready");
+      } else {
+        this._state = TransportState.Ready;
+        this.emit("ready");
+      }
+    }).catch((err) => {
+      if (this.listenerCount("error") > 0) {
+        this.emit("error", err);
+      }
+    });
+  }
+  async send(bytes) {
+    const framed = await this._packetCodec.encode(bytes);
+    if (this._state !== TransportState.Ready) {
+      throw new MtcuteError("Transport is not READY");
+    }
+    const written = this._socket.write(framed);
+    if (written < framed.length) {
+      this._sendOnceDrained.push(framed.subarray(written));
+    }
+  }
+  _sendOnceDrained = [];
+  handleDrained() {
+    while (this._sendOnceDrained.length) {
+      const data = this._sendOnceDrained.shift();
+      const written = this._socket.write(data);
+      if (written < data.length) {
+        this._sendOnceDrained.unshift(data.subarray(written));
+        break;
+      }
+    }
+  }
+}
+class TcpTransport extends BaseTcpTransport {
+  _packetCodec = new IntermediatePacketCodec();
+}
+class BaseTelegramClient extends BaseTelegramClient$1 {
+  constructor(opts) {
+    if (!opts.platformless) setPlatform(new BunPlatform());
+    super({
+      crypto: new BunCryptoProvider(),
+      transport: () => new TcpTransport(),
+      ...opts,
+      storage: typeof opts.storage === "string" ? new SqliteStorage(opts.storage) : opts.storage ?? new SqliteStorage("client.session")
+    });
+  }
+}
+class TelegramClient extends TelegramClient$1 {
+  constructor(opts) {
+    if ("client" in opts) {
+      super(opts);
+      return;
+    }
+    super({
+      client: new BaseTelegramClient(opts),
+      disableUpdates: opts.disableUpdates,
+      skipConversationUpdates: opts.skipConversationUpdates,
+      updates: opts.updates
+    });
+  }
+  _rl;
+  /**
+   * Tiny wrapper over Node `readline` package
+   * for simpler user input for `.start()` method.
+   *
+   * Associated `readline` interface is closed
+   * after `start()` returns, or with the client.
+   *
+   * @param text  Text of the question
+   */
+  input(text) {
+    if (!this._rl) {
+      this._rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+    }
+    return new Promise((res) => this._rl?.question(text, res));
+  }
+  close() {
+    this._rl?.close();
+    return super.close();
+  }
+  start(params = {}) {
+    if (!params.botToken) {
+      if (!params.phone) params.phone = () => this.input("phone > ");
+      if (!params.code) params.code = () => this.input("code > ");
+      if (!params.password) {
+        params.password = () => this.input("2fa password > ");
+      }
+    }
+    return super.start(params).then((user) => {
+      if (this._rl) {
+        this._rl.close();
+        delete this._rl;
+      }
+      return user;
+    });
+  }
+  run(params, then) {
+    if (typeof params === "function") {
+      then = params;
+      params = {};
+    }
+    this.start(params).then(then).catch((err) => this.emitError(err));
+  }
+  downloadToFile(filename, location, params) {
+    return downloadToFile(this, filename, location, params);
+  }
+  downloadAsNodeStream(location, params) {
+    return downloadAsNodeStream(this, location, params);
+  }
+}
+let _registered = false;
+class TelegramWorker extends TelegramWorker$1 {
+  registerWorker(handler) {
+    if (!parentPort) {
+      throw new Error("TelegramWorker must be created from a worker thread");
+    }
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    const port = parentPort;
+    const respond = port.postMessage.bind(port);
+    parentPort.on("message", (message) => handler(message, respond));
+    return respond;
+  }
+}
+class TelegramWorkerPort extends TelegramWorkerPort$1 {
+  constructor(options) {
+    setPlatform(new BunPlatform());
+    super(options);
+    this.options = options;
+  }
+  connectToWorker(worker, handler) {
+    if (!(worker instanceof Worker)) {
+      throw new TypeError("Only worker_threads are supported");
+    }
+    const send = worker.postMessage.bind(worker);
+    worker.on("message", handler);
+    return [
+      send,
+      () => {
+        worker.off("message", handler);
+      }
+    ];
+  }
+}
+export {
+  BaseTcpTransport,
+  BaseTelegramClient,
+  BunCryptoProvider,
+  BunPlatform,
+  SqliteStorage,
+  SqliteStorageDriver,
+  TcpTransport,
+  TelegramClient,
+  TelegramWorker,
+  TelegramWorkerPort
+};

package/methods/download-file.d.ts

@@ -1,4 +1,4 @@
-import type { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
+import { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
 /**
  * Download a remote file to a local file (only for NodeJS).
  * Promise will resolve once the download is complete.

package/methods/download-node-stream.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from 'node:stream';
-import type { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
+import { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
 /**
  * Download a remote file as a Node.js Readable stream
  * (discouraged under Bun, since Web Streams are first-class).

package/methods.d.cts

@@ -0,0 +1,3 @@
+export { downloadToFile } from './methods/download-file.js';
+export { downloadAsNodeStream } from './methods/download-node-stream.js';
+export * from '@mtcute/core/methods.js';

package/methods.js

@@ -1,4 +1,6 @@
-export { downloadToFile } from './methods/download-file.js';
-export { downloadAsNodeStream } from './methods/download-node-stream.js';
-export * from '@mtcute/core/methods.js';
-//# sourceMappingURL=methods.js.map
+import { downloadAsNodeStream, downloadToFile } from "./chunks/es/BmtxbrWZ.js";
+export * from "@mtcute/core/methods.js";
+export {
+  downloadAsNodeStream,
+  downloadToFile
+};