mtproto-checker 0.1.1 → 0.2.0

package/README.md

@@ -1,335 +1,249 @@
-# MTProto Checker ⚡
+# 🔍 mtproto-checker
 
-Fast Telegram MTProto proxy checker powered by TDLib. It does a real `testProxy`
-handshake through every proxy, so a green result means the proxy is much more
-likely to work in Telegram than with a plain TCP/TLS port check.
+Telegram MTProto proxy health checker powered by **TDLib**. Performs a real `testProxy` handshake through each proxy — the same protocol path tdesktop uses. If it says ✅, the proxy **actually works** in Telegram.
 
-## What It Does
+## ⚡ Features
 
-- ✅ Parses `tg://proxy` and `https://t.me/proxy` links
-- 🌐 Loads proxy lists from remote URLs, local files, or `stdin`
-- 🧹 Removes duplicates by `server:port:secret`
-- 🔐 Supports hex and base64url MTProto secrets
-- 🕵️ Extracts Fake-TLS SNI from `ee...` secrets and supports padded `dd...` secrets
-- 🚀 Checks proxies concurrently via TDLib `testProxy`
-- 💪 Re-checks survivors with `--iterations` to find the most stable proxies
-- 📄 Writes both a full JSON report and a ready-to-use TXT list
+- 🤝 Real MTProto handshake (not just a port scan)
+- 📡 Check from remote URLs, local files, or single proxy links
+- 🔄 Multi-iteration filtering — only survivors advance
+- 🌐 Built-in HTTP API server with Basic Auth
+- 🧹 Auto de-duplication by `server:port:secret`
+- 📊 Sorted output: working first, fastest on top
+- 🔐 Fake-TLS SNI extraction from `ee`-prefixed secrets
 
-## Requirements
-
-- Node.js 18+ recommended
-- npm
-- Telegram API credentials:
-  - `TG_API_ID`
-  - `TG_API_HASH`
-
-Get API credentials from [my.telegram.org](https://my.telegram.org).
-
-> No Telegram login or phone number is required. The credentials are only used
-> to initialize TDLib before running `testProxy`.
-
-## Installation
+## 📦 Install
 
 ```bash
-git clone git@github.com:Tar4s/mtproto-checker.git
-cd mtproto-checker
-npm install
+npm install mtproto-checker
 ```
 
-Optional, if you want the `check-proxies` command available locally:
+Or clone locally:
 
 ```bash
-npm link
+git clone https://github.com/Tar4s/mtproto-checker.git
+cd mtproto-checker
+npm install
 ```
 
-### GitHub Packages
-
-This project can also be published to GitHub Packages as
-`@tar4s/mtproto-checker`. GitHub's npm registry requires scoped package names,
-so the GitHub Packages workflow applies that scoped name during publishing.
-
-To install from GitHub Packages:
+GitHub Packages (scoped):
 
 ```bash
 npm config set @tar4s:registry https://npm.pkg.github.com
 npm install @tar4s/mtproto-checker
 ```
 
-Private packages require authentication with a GitHub personal access token that
-has `read:packages`.
-
-## Quick Start
-
-Start the HTTP API server:
-
-```bash
-TG_API_ID=12345 \
-TG_API_HASH=abcdef \
-CHECK_AUTH_USER=admin \
-CHECK_AUTH_PASSWORD=secret \
-node check.js
-```
-
-By default it listens on port `3080`. Override it with `PORT`.
-
-Check URLs listed in `urls.txt`:
-
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef npm start -- --sources urls.txt
-```
+> **Requirements:** Node.js ≥ 18 · `TG_API_ID` + `TG_API_HASH` from [my.telegram.org](https://my.telegram.org)
+> No phone login needed — credentials only initialize TDLib.
 
-Equivalent direct Node.js run:
+## 🔑 Environment Variables
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js --sources urls.txt
-```
+| Variable | Required | Description |
+|----------|:--------:|-------------|
+| `TG_API_ID` | ✅ | Telegram API ID |
+| `TG_API_HASH` | ✅ | Telegram API Hash |
+| `CHECK_AUTH_USER` | 🌐 | HTTP Basic Auth username (server mode) |
+| `CHECK_AUTH_PASSWORD` | 🌐 | HTTP Basic Auth password (server mode) |
+| `PORT` | ❌ | Server port (default `3080`) |
 
-With `npm link`:
+## 🚀 CLI Usage
 
 ```bash
-TG_API_ID=12345 TG_API_HASH=abcdef check-proxies --sources urls.txt
+TG_API_ID=12345 TG_API_HASH=abcdef node check.js [sources] [options]
 ```
 
-Check one proxy link directly:
+### Input Methods
 
 ```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js \
-  --proxy 'tg://proxy?server=quackton.life&port=443&secret=7mX8dVOh9cqLULccAVs4ciR5YW5kZXgucnU'
-```
+# Single proxy link
+node check.js --proxy "tg://proxy?server=1.2.3.4&port=443&secret=ee..."
 
-## Input Sources
-
-You can provide proxies in several ways.
-
-### 1. Direct Proxy Link
-
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js \
-  --proxy 'https://t.me/proxy?server=1.2.3.4&port=443&secret=...'
-```
+# Remote URLs (positional or --url flag, repeatable)
+node check.js https://example.com/proxies.txt
+node check.js --url URL1 --url URL2
 
-### 2. Source URL File
+# File with source URLs (one per line, # comments ok)
+node check.js --sources urls.txt
 
-`urls.txt` contains one remote text-list URL per line:
+# Local proxy file
+node check.js ./my-proxies.txt
 
-```txt
-https://example.com/proxies.txt
-https://example.com/more-proxies.txt
+# Stdin
+cat proxies.txt | node check.js
 ```
 
-Run:
+### ⚙️ Options
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js --sources urls.txt
-```
-
-### 3. One Or More Remote URLs
+| Flag | Default | Description |
+|------|:-------:|-------------|
+| `--proxy <link>` | — | Check one proxy link directly |
+| `--url <url>` | — | Add a source URL (repeatable) |
+| `--sources <file>` | — | File of source URLs |
+| `--dc <1-5>` | `2` | Data center for `testProxy` |
+| `--timeout <sec>` | `10` | Per-proxy timeout |
+| `--concurrency <n>` | `30` | Parallel checks (lower = more accurate ms) |
+| `--iterations <n>` | `1` | Re-check rounds; only working proxies advance |
+| `--out <prefix>` | `result` | Output prefix → `.json` + `.txt` |
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js \
-  --url https://example.com/proxies.txt \
-  --url https://example.com/more-proxies.txt
-```
+### 📄 Output Files
 
-Positional HTTP URLs also work:
+| File | Content |
+|------|---------|
+| `result.json` | Full report: server, port, SNI, latency, error, link |
+| `result.txt` | Working proxy links only, fastest first |
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js https://example.com/proxies.txt
-```
+## 🌐 HTTP API Server
 
-### 4. Local Proxy File
+Start with **no arguments**:
 
 ```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js proxies.txt
+TG_API_ID=12345 TG_API_HASH=abcdef \
+CHECK_AUTH_USER=admin CHECK_AUTH_PASSWORD=secret \
+node check.js
 ```
 
-### 5. stdin
-
-```bash
-cat proxies.txt | TG_API_ID=12345 TG_API_HASH=abcdef node check.js
 ```
-
-Input files may contain blank lines and `#` comments.
-
-## CLI Options
-
-| Option | Default | Description |
-| --- | ---: | --- |
-| `--url <url>` | none | Add a remote proxy-list URL. Can be repeated. |
-| `--proxy <link>` | none | Check one `tg://proxy` or `https://t.me/proxy` link directly. |
-| `--sources <file>` | none | Read remote source URLs from a file, one URL per line. |
-| `--dc <1-5>` | `2` | Telegram data center ID used for `testProxy`. |
-| `--timeout <sec>` | `10` | Per-proxy TDLib timeout in seconds. Decimals are allowed. |
-| `--concurrency <n>` | `30` | Number of proxies checked in parallel. Lower values can produce steadier latency numbers. |
-| `--iterations <num>` | `1` | Number of check rounds. Each next round checks only proxies that passed the previous one. |
-| `--out <prefix>` | `result` | Output file prefix. Writes `<prefix>.json` and `<prefix>.txt`. |
-
-Environment variables:
-
-| Variable | Required | Description |
-| --- | --- | --- |
-| `TG_API_ID` | yes | Telegram API ID from `my.telegram.org`. |
-| `TG_API_HASH` | yes | Telegram API hash from `my.telegram.org`. |
-| `CHECK_AUTH_USER` | HTTP server only | Basic auth username. |
-| `CHECK_AUTH_PASSWORD` | HTTP server only | Basic auth password. |
-| `PORT` | no | HTTP server port. Defaults to `3080`. |
-
-## HTTP API
-
-Running `node check.js` without CLI arguments starts the HTTP server. The server
-requires Basic auth and exposes one endpoint:
-
-```http
-POST /check
-Content-Type: application/json
-Authorization: Basic ...
-
-{ "url": "https://example.com/proxies.txt" }
+[mtproto-checker] ⚡ HTTP server listening on http://localhost:3080
+[mtproto-checker]   POST /check (Basic auth: admin:***)
 ```
 
-The `url` field accepts either a remote `http(s)` proxy list or one direct
-`tg://proxy` / `https://t.me/proxy` link.
-
-Example:
+### `POST /check`
 
 ```bash
-curl -u admin:secret \
-  -H 'content-type: application/json' \
-  -d '{"url":"https://example.com/proxies.txt"}' \
-  http://127.0.0.1:3080/check
+curl -u admin:secret http://localhost:3080/check \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://example.com/proxies.txt", "iterations": 2, "concurrency": 20}'
 ```
 
-Direct proxy link example:
+**Request body:**
 
-```bash
-curl -u admin:secret \
-  -H 'content-type: application/json' \
-  -d '{"url":"tg://proxy?server=quackton.life&port=443&secret=7mX8dVOh9cqLULccAVs4ciR5YW5kZXgucnU"}' \
-  http://127.0.0.1:3080/check
-```
+| Field | Type | Default | Description |
+|-------|------|:-------:|-------------|
+| `url` | string | — | Proxy list URL or single `tg://proxy` link |
+| `iterations` | int | `1` | Check rounds |
+| `concurrency` | int | `30` | Parallel checks |
 
-Response:
+**Response:**
 
 ```json
 {
   "url": "https://example.com/proxies.txt",
-  "count": 1,
-  "working": 1,
+  "iterations": 2,
+  "concurrency": 20,
+  "count": 150,
+  "working": 42,
   "results": [
-    {
-      "server": "1.2.3.4",
-      "port": 443,
-      "sni": "example.com",
-      "ok": true,
-      "ms": 841,
-      "error": null,
-      "link": "tg://proxy?server=1.2.3.4&port=443&secret=..."
-    }
+    { "server": "1.2.3.4", "port": 443, "sni": "example.com", "ok": true, "ms": 312, "error": null, "link": "tg://proxy?..." }
   ]
 }
 ```
 
-## Output
+**Error codes:** `400` bad request · `401` unauthorized · `404` wrong endpoint · `405` wrong method · `502` upstream fetch failed
 
-By default the checker writes:
+## 📚 Library API
 
-- `result.json` — full report for the final completed round
-- `result.txt` — working proxy links from the final completed round, fastest first
+```js
+const { checkProxyLink, checkProxiesFromURIs, startServer } = require('mtproto-checker')
+```
 
-Example JSON item:
+### `checkProxyLink(link, opts)` → `Promise<Array>`
 
-```json
-{
-  "server": "1.2.3.4",
-  "port": 443,
-  "sni": "example.com",
-  "ok": true,
-  "ms": 841,
-  "error": null,
-  "link": "tg://proxy?server=1.2.3.4&port=443&secret=..."
-}
-```
+Check a single `tg://proxy` or `https://t.me/proxy` link.
 
-Use a custom prefix:
+```js
+const results = await checkProxyLink(
+  'tg://proxy?server=1.2.3.4&port=443&secret=ee...',
+  { apiId: 12345, apiHash: 'abcdef' }
+)
+```
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js --sources urls.txt --out fresh
 ```
+[mtproto-checker] Checking 1.2.3.4:443 [example.com]...
+[mtproto-checker] ✓ 312ms
+```
+
+### `checkProxiesFromURIs(uris, opts)` → `Promise<Array>`
 
-This creates `fresh.json` and `fresh.txt`.
+Check proxies from remote URLs, local files, or both. Auto-detects type per entry.
 
-## Practical Examples
+```js
+// Remote
+const results = await checkProxiesFromURIs(
+  'https://example.com/proxies.txt',
+  { apiId: 12345, apiHash: 'abcdef' }
+)
 
-Fast broad scan:
+// Local
+const results = await checkProxiesFromURIs('./proxies.txt', opts)
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js --sources urls.txt --concurrency 80 --timeout 7
+// Mix
+const results = await checkProxiesFromURIs([
+  'https://example.com/list1.txt',
+  './local-list.txt',
+  'https://example.com/list2.txt'
+], { apiId: 12345, apiHash: 'abcdef', iterations: 2, concurrency: 20 })
 ```
 
-More conservative latency check:
-
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js --sources urls.txt --concurrency 10 --timeout 15
 ```
+[mtproto-checker] Loading 3 source(s)...
+  ↓ https://example.com/list1.txt
+  ◈ ./local-list.txt
+  ↓ https://example.com/list2.txt
+[mtproto-checker] Checking 150 proxies (dc=2, timeout=10s, concurrency=30, iterations=2)...
 
-Find the most stable proxies across several rounds:
+  [  1/150] ✓   312ms  1.2.3.4:443 [example.com]
+  [  2/150] ✗ Timeout  5.6.7.8:443
+  ...
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js --sources urls.txt --iterations 3 --out stable
+[mtproto-checker] Done: 42/150 working.
 ```
 
-Test against another Telegram DC:
+### `startServer(opts)` → `Promise<http.Server>`
 
-```bash
-TG_API_ID=12345 TG_API_HASH=abcdef node check.js --sources urls.txt --dc 4
+Start the HTTP API server programmatically.
+
+```js
+const server = await startServer({
+  apiId: 12345,
+  apiHash: 'abcdef',
+  user: 'admin',
+  password: 'secret',
+  port: 8080
+})
 ```
 
-Check a pasted list:
+All fields are optional — falls back to env vars if omitted.
 
-```bash
-pbpaste | TG_API_ID=12345 TG_API_HASH=abcdef node check.js --out pasted
-```
+### `opts` Reference
 
-## Programmatic Usage
+| Key | Type | Default | Description |
+|-----|------|:-------:|-------------|
+| `apiId` | number | — | Telegram API ID |
+| `apiHash` | string | — | Telegram API Hash |
+| `dc` | number | `2` | Data center (1–5) |
+| `timeout` | number | `10` | Timeout in seconds |
+| `concurrency` | number | `30` | Parallel checks |
+| `iterations` | number | `1` | Check rounds |
+| `onProgress` | function | — | `(proxy, res, index, total) => void` |
 
-```js
-const { checkProxiesFromUrls } = require('./check')
-
-const results = await checkProxiesFromUrls(
-  ['https://example.com/proxies.txt'],
-  {
-    apiId: Number(process.env.TG_API_ID),
-    apiHash: process.env.TG_API_HASH,
-    dc: 2,
-    timeout: 10,
-    concurrency: 30
-  }
-)
+## 🧩 Proxy Link Formats
 
-console.log(results)
+```
+tg://proxy?server=1.2.3.4&port=443&secret=ee...
+https://t.me/proxy?server=1.2.3.4&port=443&secret=ee...
 ```
 
-Exported helpers:
-
-- `checkProxiesFromUrls(urls, opts)`
-- `loadProxiesFromUrls(urls)`
-- `checkProxies(proxies, opts)`
-- `mergeProxies(texts)`
-- `parseLink(line)`
-- `normalizeSecret(secret)`
-- `faketlsSni(hexSecret)`
+Secrets: hex (`ee...`, `dd...`), plain hex, or base64url — auto-detected. `tg://socks` links are ignored.
 
-## Notes & Troubleshooting
+## 🛠 Troubleshooting
 
-- If you see `Set TG_API_ID and TG_API_HASH`, export both credentials or prefix
-  the command with them.
-- If remote URLs fail on old Node.js versions, upgrade to Node.js 18+.
-- If checks are noisy, reduce `--concurrency`.
-- If you want only resilient proxies, increase `--iterations`; `result.txt`
-  will contain proxies that survived the final round.
-- Only MTProto proxy links are checked. `tg://socks` links are ignored.
-- Temporary TDLib files are created in `.proxy-checker-td/` and removed after the run.
+| Problem | Fix |
+|---------|-----|
+| `Set TG_API_ID and TG_API_HASH` | Export both env vars |
+| Noisy latency | Reduce `--concurrency` |
+| Need stable proxies only | Increase `--iterations` |
+| TDLib leftover files | `.proxy-checker-td/` is auto-cleaned after each run |
 
-## License
+## 📜 License
 
-No license file is currently included.
+ISC

package/check.js

@@ -415,6 +415,102 @@ async function checkSingleUrl(url, opts) {
   return checker(proxies, opts)
 }
 
+/**
+ * Load proxies from a local file path.
+ * @param {string} filePath - path to a text file with proxy links (one per line)
+ * @returns {Array} de-duplicated parsed proxies
+ */
+function loadProxiesFromFile(filePath) {
+  const text = fs.readFileSync(filePath, 'utf8')
+  return mergeProxies([text])
+}
+
+/**
+ * Check proxies from URIs — supports both remote URLs (http/https) and local
+ * file paths. Detects type automatically per entry.
+ * @param {string|string[]} uris - URL(s) or file path(s) with proxy links
+ * @param {{apiId: number, apiHash: string, dc?: number, timeout?: number, concurrency?: number, iterations?: number, onProgress?: Function}} opts
+ * @returns {Promise<Array<{proxy: object, ok: boolean, ms: number, error: string|null}>>}
+ */
+async function checkProxiesFromURIs(uris, opts) {
+  const list = Array.isArray(uris) ? uris : [uris]
+  console.error(`[mtproto-checker] Loading ${list.length} source(s)...`)
+  const texts = await Promise.all(list.map(uri => {
+    if (/^https?:\/\//i.test(uri)) {
+      console.error(`  ↓ ${uri}`)
+      return fetchText(uri).catch(err => { console.error(`  ✗ Skipping ${uri}: ${err.message}`); return '' })
+    }
+    console.error(`  ◈ ${uri}`)
+    return Promise.resolve(fs.readFileSync(uri, 'utf8'))
+  }))
+  const proxies = mergeProxies(texts)
+  if (proxies.length === 0) {
+    console.error('[mtproto-checker] No valid proxy links found.')
+    return []
+  }
+  const iterations = opts.iterations ?? 1
+  console.error(`[mtproto-checker] Checking ${proxies.length} proxies (dc=${opts.dc ?? 2}, timeout=${opts.timeout ?? 10}s, concurrency=${opts.concurrency ?? 30}, iterations=${iterations})...\n`)
+  const results = await runIterativeChecks(proxies, iterations, (batch, iteration) => {
+    if (iterations > 1) console.error(`[mtproto-checker] Iteration ${iteration}/${iterations}: ${batch.length} proxies\n`)
+    return checkProxies(batch, {
+      ...opts,
+      onProgress: (proxy, res, index, total) => {
+        const tag = res.ok ? `✓ ${String(res.ms).padStart(5)}ms` : `✗ ${res.error}`
+        const sni = proxy.sni ? ` [${proxy.sni}]` : ''
+        console.error(`  [${String(index + 1).padStart(3)}/${total}] ${tag}  ${proxy.server}:${proxy.port}${sni}`)
+        if (opts.onProgress) opts.onProgress(proxy, res, index, total)
+      }
+    })
+  })
+  const working = results.filter(c => c.ok).length
+  console.error(`\n[mtproto-checker] Done: ${working}/${proxies.length} working.`)
+  return results
+}
+
+/**
+ * Check a single tg://proxy or t.me/proxy link via real MTProto handshake.
+ * @param {string} link - proxy link (tg://proxy?... or https://t.me/proxy?...)
+ * @param {{apiId: number, apiHash: string, dc?: number, timeout?: number, iterations?: number, onProgress?: Function}} opts
+ * @returns {Promise<Array<{proxy: object, ok: boolean, ms: number, error: string|null}>>}
+ * @throws if the link is not a valid MTProto proxy link
+ */
+async function checkProxyLink(link, opts) {
+  const proxy = parseLink(link)
+  if (!proxy) throw new Error('Invalid proxy link. Expected tg://proxy?... or https://t.me/proxy?...')
+  const sni = proxy.sni ? ` [${proxy.sni}]` : ''
+  console.error(`[mtproto-checker] Checking ${proxy.server}:${proxy.port}${sni}...`)
+  const results = await runIterativeChecks([proxy], opts.iterations ?? 1, batch => checkProxies(batch, opts))
+  const r = results[0]
+  if (r)
+    console.error(`[mtproto-checker] ${r.ok ? `✓ ${r.ms}ms` : `✗ ${r.error}`}`)
+  return results
+}
+
+async function loadSingleUrlProxies(url, opts = {}) {
+  const directProxy = parseLink(url)
+  if (directProxy) return [directProxy]
+
+  let parsed
+  try {
+    parsed = new URL(url)
+  } catch {
+    throw new Error('url must be a proxy link or an http or https URL')
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error('url must be a proxy link or an http or https URL')
+  }
+
+  const fetcher = opts.fetcher || fetchText
+  const text = await fetcher(url)
+  return mergeProxies([text])
+}
+
+async function checkRequestUrl(url, opts) {
+  const proxies = await loadSingleUrlProxies(url, opts)
+  const checker = opts.checker || checkProxies
+  return runIterativeChecks(proxies, opts.iterations ?? 1, batch => checker(batch, opts))
+}
+
 async function resolveInputProxies(opts, deps = {}) {
   const readFile = deps.readFile || (file => fs.readFileSync(file, 'utf8'))
   const readInputFn = deps.readInput || readInput
@@ -554,11 +650,23 @@ function createServer({ auth, checkUrl, logger = console.error }) {
         jsonResponse(res, statusCode, { error: 'Request body must include url' })
         return
       }
+      const iterations = body.iterations === undefined ? 1 : body.iterations
+      if (!Number.isInteger(iterations) || iterations < 1) {
+        statusCode = 400
+        jsonResponse(res, statusCode, { error: 'iterations must be a positive integer' })
+        return
+      }
+      const concurrency = body.concurrency === undefined ? 30 : body.concurrency
+      if (!Number.isInteger(concurrency) || concurrency < 1) {
+        statusCode = 400
+        jsonResponse(res, statusCode, { error: 'concurrency must be a positive integer' })
+        return
+      }
 
       const url = body.url.trim()
       let results
       try {
-        results = await checkUrl(url)
+        results = await checkUrl(url, { iterations, concurrency })
       } catch (err) {
         statusCode = 502
         jsonResponse(res, statusCode, {
@@ -571,6 +679,8 @@ function createServer({ auth, checkUrl, logger = console.error }) {
       statusCode = 200
       jsonResponse(res, statusCode, {
         url,
+        iterations,
+        concurrency,
         count: report.length,
         working: report.filter(item => item.ok).length,
         results: report
@@ -590,20 +700,31 @@ function shouldStartServer(argv) {
   return argv.length === 0
 }
 
-async function startServer(env = process.env) {
-  const apiId = parseInt(env.TG_API_ID, 10)
-  const apiHash = env.TG_API_HASH
-  const user = env.CHECK_AUTH_USER
-  const password = env.CHECK_AUTH_PASSWORD
-  const port = parseInt(env.PORT || '3080', 10)
+/**
+ * Start the HTTP API server for proxy checking.
+ * @param {{apiId?: number, apiHash?: string, user?: string, password?: string, port?: number}} opts
+ *   All fields fall back to environment variables if omitted.
+ * @returns {Promise<http.Server>} the listening server instance
+ */
+async function startServer(opts = {}) {
+  const apiId = opts.apiId ?? parseInt(process.env.TG_API_ID, 10)
+  const apiHash = opts.apiHash ?? process.env.TG_API_HASH
+  const user = opts.user ?? process.env.CHECK_AUTH_USER
+  const password = opts.password ?? process.env.CHECK_AUTH_PASSWORD
+  const port = opts.port ?? parseInt(process.env.PORT || '3080', 10)
 
   if (!apiId || !apiHash) throw new Error('Set TG_API_ID and TG_API_HASH (get them at https://my.telegram.org).')
   if (!user || !password) throw new Error('Set CHECK_AUTH_USER and CHECK_AUTH_PASSWORD for HTTP Basic auth.')
-  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('PORT must be a valid TCP port.')
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('port must be a valid TCP port (1-65535).')
 
   const server = createServer({
     auth: { user, password },
-    checkUrl: async url => checkSingleUrl(url, { apiId, apiHash })
+    checkUrl: async (url, requestOpts) => checkRequestUrl(url, {
+      apiId,
+      apiHash,
+      iterations: requestOpts.iterations,
+      concurrency: requestOpts.concurrency
+    })
   })
 
   await new Promise((resolve, reject) => {
@@ -614,7 +735,8 @@ async function startServer(env = process.env) {
     })
   })
 
-  console.error(`MTProto checker HTTP server listening on :${port}`)
+  console.error(`[mtproto-checker] ⚡ HTTP server listening on http://localhost:${port}`)
+  console.error(`[mtproto-checker]   POST /check (Basic auth: ${user}:***)`)
   return server
 }
 
@@ -681,7 +803,8 @@ async function main() {
   process.exit(0)
 }
 
-module.exports = { checkSingleUrl, configureTdlibOnce, createServer, parseArgs, resolveInputProxies, checkProxiesFromUrls, loadProxiesFromUrls, checkProxies, runIterativeChecks, mergeProxies, parseLink, normalizeSecret, faketlsSni, shouldStartServer, startServer }
+module.exports = { checkProxyLink, checkProxiesFromURIs, startServer }
+module.exports._internals = { checkRequestUrl, checkSingleUrl, configureTdlibOnce, createServer, parseArgs, resolveInputProxies, runIterativeChecks, shouldStartServer }
 
 if (require.main === module) (shouldStartServer(process.argv.slice(2)) ? startServer() : main()).catch(err => {
   console.error(err)

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "mtproto-checker",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Check Telegram MTProto proxies via a real TDLib handshake (testProxy), like tdesktop does",
+  "main": "check.js",
+  "exports": {
+    ".": "./check.js"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Tar4s/mtproto-checker"
+    "url": "git+https://github.com/Tar4s/mtproto-checker.git"
   },
   "bugs": {
     "url": "https://github.com/Tar4s/mtproto-checker/issues"
@@ -22,7 +26,7 @@
     "start": "node check.js"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "dependencies": {
     "tdl": "^8.0.2",

package/urls.txt

@@ -1,4 +0,0 @@
-https://raw.githubusercontent.com/SoliSpirit/mtproto/refs/heads/master/all_proxies.txt
-https://raw.githubusercontent.com/kort0881/telegram-proxy-collector/refs/heads/main/proxy_all.txt
-https://raw.githubusercontent.com/Surfboardv2ray/TGProto/refs/heads/main/proxies.txt
-https://raw.githubusercontent.com/Therealwh/MTPproxyLIST/refs/heads/main/verified/proxy_all_tme_verified.txt