@emaxe/tuigram 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emaxe/tuigram",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Полнофункциональный TUI & CLI клиент Telegram на Node.js на базе MTProto (teleproto)",
   "type": "module",
   "exports": {
@@ -13,6 +13,9 @@
     "bin/",
     "src/",
     "README.md",
+    "README.ru.md",
+    "CHANGELOG.md",
+    "CHANGELOG.ru.md",
     "LICENSE",
     ".env.example"
   ],

package/src/cli/init.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import input from "input";
 import { bold, cyan, green, yellow, dim } from "colorette";
-import { config } from "../config.js";
+import { config, formatProxyUrl } from "../config.js";
 
 /** Сколько раз переспрашивать значение, прежде чем сдаться. */
 const MAX_ATTEMPTS = 3;
@@ -193,5 +193,6 @@ export function cmdPaths() {
     console.log(`  Сессия:          ${config.sessionPath} ${sessionExists ? green("(есть)") : dim("(нет)")}`);
     console.log(`  Загрузки:        ${config.downloadsDir}`);
     console.log(`  Ключи API:       ${config.apiId && config.apiHash ? green("заданы") : yellow("не заданы — запустите tuigram init")}`);
+    console.log(`  Прокси:          ${config.proxy ? green(formatProxyUrl(config.proxy)) : dim("не используется")}`);
     console.log("");
 }

package/src/config.js

@@ -110,6 +110,129 @@ function readVersion() {
     }
 }
 
+/**
+ * @typedef {Object} ProxyConfig
+ * @property {"http"|"https"|"socks5"|"socks4"} type - Протокол прокси
+ * @property {string} host - Адрес сервера прокси
+ * @property {number} port - Порт сервера прокси
+ * @property {string} [username] - Логин пользователя
+ * @property {string} [password] - Пароль пользователя
+ * @property {number} [timeout] - Таймаут в секундах
+ * @property {string} ip - Хост прокси (для совместимости с MTProto)
+ * @property {4|5} [socksType] - Тип SOCKS-прокси
+ * @property {boolean} [http] - Флаг HTTP-прокси
+ */
+
+/**
+ * Нормализует тип прокси из строки протокола.
+ * @param {string} [raw]
+ * @returns {"http"|"https"|"socks5"|"socks4"}
+ */
+function normalizeProxyType(raw) {
+    const clean = String(raw || "").toLowerCase().replace(/:$/, "").trim();
+    if (clean === "https") return "https";
+    if (clean === "socks4" || clean === "socks4a") return "socks4";
+    if (clean === "socks5" || clean === "socks5h" || clean === "socks") return "socks5";
+    return "http";
+}
+
+/**
+ * Разбирает параметры прокси из переменных окружения или переданного объекта.
+ * Поддерживает URL-формат (PROXY_URL, HTTPS_PROXY, HTTP_PROXY, ALL_PROXY)
+ * и отдельные переменные (PROXY_TYPE, PROXY_HOST, PROXY_PORT, PROXY_USERNAME, PROXY_PASSWORD).
+ * @param {Record<string, string|undefined>} [env=process.env]
+ * @returns {ProxyConfig|null}
+ */
+export function parseProxyConfig(env = process.env) {
+    const rawUrl = env.PROXY_URL || env.proxy_url || (!env.PROXY_HOST && !env.PROXY_IP && !env.proxy_host && !env.proxy_ip
+        ? (env.HTTPS_PROXY || env.https_proxy || env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy)
+        : undefined);
+
+    let type = "http";
+    let host = "";
+    let port = 0;
+    let username = "";
+    let password = "";
+
+    if (rawUrl && typeof rawUrl === "string" && rawUrl.trim()) {
+        let urlStr = rawUrl.trim();
+        // Добавляем схему по умолчанию, если передан host:port без префикса
+        if (!/^[a-zA-Z0-9+-.]+:\/\//.test(urlStr)) {
+            const defaultScheme = (env.PROXY_TYPE || "http").toLowerCase().replace(/:$/, "");
+            urlStr = `${defaultScheme}://${urlStr}`;
+        }
+
+        try {
+            const parsed = new URL(urlStr);
+            type = normalizeProxyType(parsed.protocol);
+            host = parsed.hostname.replace(/^\[(.*)\]$/, "$1");
+            port = parsed.port ? parseInt(parsed.port, 10) : (type === "https" ? 443 : (type.startsWith("socks") ? 1080 : 8080));
+            if (parsed.username) username = decodeURIComponent(parsed.username);
+            if (parsed.password) password = decodeURIComponent(parsed.password);
+        } catch {
+            return null;
+        }
+    } else if (env.PROXY_HOST || env.PROXY_IP) {
+        type = normalizeProxyType(env.PROXY_TYPE || "http");
+        host = String(env.PROXY_HOST || env.PROXY_IP).trim();
+        const defaultPort = type === "https" ? 443 : (type.startsWith("socks") ? 1080 : 8080);
+        port = env.PROXY_PORT ? parseInt(String(env.PROXY_PORT).trim(), 10) : defaultPort;
+        username = String(env.PROXY_USERNAME || env.PROXY_USER || "").trim();
+        password = String(env.PROXY_PASSWORD || env.PROXY_PASS || "").trim();
+    } else {
+        return null;
+    }
+
+    if (!host || !port || isNaN(port) || port <= 0 || port > 65535) {
+        return null;
+    }
+
+    const rawTimeout = env.PROXY_TIMEOUT ? parseInt(String(env.PROXY_TIMEOUT).trim(), 10) : 10;
+    const timeout = isNaN(rawTimeout) || rawTimeout <= 0 ? 10 : rawTimeout;
+
+    /** @type {ProxyConfig} */
+    const result = {
+        type,
+        host,
+        port,
+        ip: host,
+        timeout,
+    };
+
+    if (username) result.username = username;
+    if (password) result.password = password;
+
+    if (type === "socks5") {
+        result.socksType = 5;
+    } else if (type === "socks4") {
+        result.socksType = 4;
+    } else {
+        result.http = true;
+    }
+
+    return result;
+}
+
+/**
+ * Форматирует конфигурацию прокси в строку для вывода в терминал.
+ * Пароль маскируется звездочками в целях безопасности.
+ * @param {ProxyConfig|null} proxy
+ * @returns {string}
+ */
+export function formatProxyUrl(proxy) {
+    if (!proxy) return "не используется";
+
+    let auth = "";
+    if (proxy.username) {
+        auth = proxy.password
+            ? `${encodeURIComponent(proxy.username)}:***@`
+            : `${encodeURIComponent(proxy.username)}@`;
+    }
+
+    const host = proxy.host.includes(":") ? `[${proxy.host}]` : proxy.host;
+    return `${proxy.type}://${auth}${host}:${proxy.port}`;
+}
+
 export const config = {
     packageRoot,
     /** @deprecated оставлено для обратной совместимости, равно packageRoot */
@@ -129,6 +252,8 @@ export const config = {
     autoScroll: String(process.env.AUTO_SCROLL || "true").toLowerCase() === "true",
     showTyping: String(process.env.SHOW_TYPING || "true").toLowerCase() === "true",
 
+    proxy: parseProxyConfig(),
+
     /**
      * Путь к файлу сессии.
      * @returns {string}

package/src/telegram/client.js

@@ -4,6 +4,7 @@ import { StringSession } from "teleproto/sessions/index.js";
 import { Logger, LogLevel } from "teleproto/extensions/Logger.js";
 import { config } from "../config.js";
 import { saveSessionFile, readFileSafe } from "../utils/storage.js";
+import { TuiGramNetSockets } from "./socket.js";
 
 /**
  * Читает сохранённую строку сессии.
@@ -42,17 +43,24 @@ export function clearSession() {
 export function buildClient(sessionString = readSession()) {
     config.assertCredentials();
 
+    const clientParams = {
+        connectionRetries: 10,
+        autoReconnect: true,
+        retryDelay: 1500,
+        baseLogger: new Logger(LogLevel.ERROR),
+        useWSS: false,
+    };
+
+    if (config.proxy) {
+        clientParams.proxy = config.proxy;
+        clientParams.networkSocket = TuiGramNetSockets;
+    }
+
     const client = new TelegramClient(
         new StringSession(sessionString),
         config.apiId,
         config.apiHash,
-        {
-            connectionRetries: 10,
-            autoReconnect: true,
-            retryDelay: 1500,
-            baseLogger: new Logger(LogLevel.ERROR),
-            useWSS: false,
-        }
+        clientParams
     );
 
     return client;

package/src/telegram/socket.js

@@ -0,0 +1,224 @@
+/**
+ * Сетевой транспорт для MTProto с поддержкой прокси (HTTP CONNECT, SOCKS5, SOCKS4).
+ */
+import http from "node:http";
+import https from "node:https";
+import net from "node:net";
+import { PromisedNetSockets } from "teleproto/extensions/PromisedNetSockets.js";
+import { SocksClient } from "socks";
+
+/**
+ * Создаёт TCP-туннель через HTTP/HTTPS прокси методом HTTP CONNECT.
+ * Поддерживает как прокси с Basic-авторизацией, так и без неё.
+ * @param {object} params
+ * @param {boolean} [params.isHttps=false] подключение к прокси-серверу по TLS
+ * @param {string} params.proxyHost адрес прокси-сервера
+ * @param {number} params.proxyPort порт прокси-сервера
+ * @param {string} params.targetHost адрес целевого сервера Telegram MTProto
+ * @param {number} params.targetPort порт целевого сервера Telegram MTProto
+ * @param {string} [params.username] логин для авторизации на прокси
+ * @param {string} [params.password] пароль для авторизации на прокси
+ * @param {number} [params.timeout=10000] таймаут установки соединения в миллисекундах
+ * @returns {Promise<import("node:net").Socket>}
+ */
+export function createHttpConnectSocket({
+    isHttps = false,
+    proxyHost,
+    proxyPort,
+    targetHost,
+    targetPort,
+    username,
+    password,
+    timeout = 10000,
+}) {
+    return new Promise((resolve, reject) => {
+        const clientModule = isHttps ? https : http;
+
+        const headers = {
+            Host: `${targetHost}:${targetPort}`,
+            "User-Agent": "TuiGram",
+            "Proxy-Connection": "Keep-Alive",
+        };
+
+        if (username || password) {
+            const auth = Buffer.from(`${username || ""}:${password || ""}`).toString("base64");
+            headers["Proxy-Authorization"] = `Basic ${auth}`;
+        }
+
+        const req = clientModule.request({
+            host: proxyHost,
+            port: proxyPort,
+            method: "CONNECT",
+            path: `${targetHost}:${targetPort}`,
+            headers,
+            timeout,
+        });
+
+        let finished = false;
+
+        const cleanup = () => {
+            req.removeAllListeners();
+        };
+
+        req.on("connect", (res, socket, head) => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+                // Если в заголовке ответа уже были данные следующего протокола, возвращаем их в сокет
+                if (head && head.length > 0) {
+                    socket.unshift(head);
+                }
+                resolve(socket);
+            } else if (res.statusCode === 407) {
+                socket.destroy();
+                reject(new Error("Ошибка авторизации на HTTP-прокси (407 Proxy Authentication Required)"));
+            } else {
+                socket.destroy();
+                reject(new Error(`HTTP-прокси вернул код ошибки: ${res.statusCode} ${res.statusMessage || ""}`.trim()));
+            }
+        });
+
+        req.on("response", (res) => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+            if (res.statusCode === 407) {
+                reject(new Error("Ошибка авторизации на HTTP-прокси (407 Proxy Authentication Required)"));
+            } else {
+                reject(new Error(`HTTP-прокси вернул код ошибки: ${res.statusCode} ${res.statusMessage || ""}`.trim()));
+            }
+        });
+
+        req.on("timeout", () => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+            req.destroy(new Error(`Таймаут подключения к HTTP-прокси (${proxyHost}:${proxyPort})`));
+        });
+
+        req.on("error", (err) => {
+            if (finished) return;
+            finished = true;
+            cleanup();
+            reject(new Error(`Не удалось подключиться к HTTP-прокси (${proxyHost}:${proxyPort}): ${err.message}`));
+        });
+
+        req.end();
+    });
+}
+
+/**
+ * Расширенный сокет для teleproto с поддержкой HTTP CONNECT и SOCKS5/4 туннелирования.
+ */
+export class TuiGramNetSockets extends PromisedNetSockets {
+    /**
+     * @param {object} [proxy]
+     * @param {number} [keepAliveInterval]
+     */
+    constructor(proxy, keepAliveInterval) {
+        // Передаём undefined в базовый класс, чтобы обойти валидацию socksType для HTTP-прокси
+        super(undefined, keepAliveInterval);
+        this.proxy = proxy;
+    }
+
+    /**
+     * Устанавливает сетевое соединение с дата-центром Telegram.
+     * @param {number} port
+     * @param {string} ip
+     * @returns {Promise<this>}
+     */
+    async connect(port, ip) {
+        this.chunks = [];
+        this.headOffset = 0;
+        this.available = 0;
+        let connected = false;
+
+        if (this.proxy) {
+            const proxyType = (this.proxy.type || "").toLowerCase();
+            const host = this.proxy.host || this.proxy.ip;
+            const proxyPort = Number(this.proxy.port);
+            const timeout = (this.proxy.timeout || 10) * 1000;
+
+            if (proxyType === "socks5" || proxyType === "socks4" || this.proxy.socksType) {
+                const socksType = this.proxy.socksType || (proxyType === "socks4" ? 4 : 5);
+                const info = await SocksClient.createConnection({
+                    proxy: {
+                        host,
+                        port: proxyPort,
+                        type: socksType,
+                        userId: this.proxy.username,
+                        password: this.proxy.password,
+                    },
+                    command: "connect",
+                    timeout,
+                    destination: {
+                        host: ip,
+                        port: port,
+                    },
+                });
+                this.client = info.socket;
+                connected = true;
+            } else if (proxyType === "http" || proxyType === "https" || this.proxy.http) {
+                this.client = await createHttpConnectSocket({
+                    isHttps: proxyType === "https",
+                    proxyHost: host,
+                    proxyPort: proxyPort,
+                    targetHost: ip,
+                    targetPort: port,
+                    username: this.proxy.username,
+                    password: this.proxy.password,
+                    timeout,
+                });
+                connected = true;
+            } else {
+                throw new Error(`Неподдерживаемый тип прокси: ${this.proxy.type}`);
+            }
+        } else {
+            this.client = new net.Socket();
+        }
+
+        this.canRead = new Promise((resolve) => {
+            this.resolveRead = resolve;
+        });
+        this.closed = false;
+
+        return new Promise((resolve, reject) => {
+            if (!this.client) {
+                return reject(new Error("Сетевой сокет не инициализирован"));
+            }
+
+            const tune = (socket) => {
+                socket.setNoDelay(true);
+                socket.setKeepAlive(this.keepAliveInterval > 0, Math.max(0, this.keepAliveInterval));
+            };
+
+            if (connected) {
+                tune(this.client);
+                this.receive();
+                resolve(this);
+            } else {
+                this.client.connect(port, ip, () => {
+                    tune(this.client);
+                    this.receive();
+                    resolve(this);
+                });
+            }
+
+            this.client.on("error", reject);
+            this.client.on("close", () => {
+                if (this.client && this.client.destroyed) {
+                    if (this.resolveRead) {
+                        this.resolveRead(false);
+                    }
+                    this.closed = true;
+                }
+            });
+        });
+    }
+
+    toString() {
+        return "TuiGramNetSocket";
+    }
+}