telegram-cli-local 0.4.0__tar.gz → 0.5.0__tar.gz

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/.agents/skills/telegram-cli/SKILL.md

@@ -43,7 +43,7 @@ If unavailable, inspect `tcli help`; do not assume newer commands exist based on
 | Cancel specific scheduled messages | `tcli scheduled me --cancel 123 124 --json` |
 | Download one attachment | `tcli download me 123 --output archive.zip --json` |
 | Configure API credentials locally | `tcli config` |
-| Sign in interactively in the user's terminal | `tcli login` |
+| Sign in interactively in the user's terminal | `tcli login` or `tcli login --qr` |
 | Check local setup, optionally connectivity | `tcli doctor` or `tcli doctor --connect` |
 | End this CLI session when requested | `tcli logout` |
 | Refresh supported agent skills offline | `tcli skills install --agent all` |
@@ -55,6 +55,8 @@ Use `thread` for the parent chain and `--around` for chronological neighbors; th
 ## Sessions, bots and deletion
 
 Select the authorized account with `--session NAME` before or after the command; default is `default`.
+Phone login reports where Telegram sent the code. If it does not arrive, run `tcli login --qr`
+in a terminal and scan it in Telegram mobile under Settings > Devices > Link Desktop Device.
 Do not assume a different named session belongs to the same person or bot. `sessions --json` lists
 local file presence only, without checking identity or authorization; `doctor --connect` shows user/bot type.
 Names use 1-32 lowercase ASCII letters/digits, underscores or hyphens, starting with letter/digit.

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/.claude/skills/telegram-cli/SKILL.md

@@ -43,7 +43,7 @@ If unavailable, inspect `tcli help`; do not assume newer commands exist based on
 | Cancel specific scheduled messages | `tcli scheduled me --cancel 123 124 --json` |
 | Download one attachment | `tcli download me 123 --output archive.zip --json` |
 | Configure API credentials locally | `tcli config` |
-| Sign in interactively in the user's terminal | `tcli login` |
+| Sign in interactively in the user's terminal | `tcli login` or `tcli login --qr` |
 | Check local setup, optionally connectivity | `tcli doctor` or `tcli doctor --connect` |
 | End this CLI session when requested | `tcli logout` |
 | Refresh supported agent skills offline | `tcli skills install --agent all` |
@@ -55,6 +55,8 @@ Use `thread` for the parent chain and `--around` for chronological neighbors; th
 ## Sessions, bots and deletion
 
 Select the authorized account with `--session NAME` before or after the command; default is `default`.
+Phone login reports where Telegram sent the code. If it does not arrive, run `tcli login --qr`
+in a terminal and scan it in Telegram mobile under Settings > Devices > Link Desktop Device.
 Do not assume a different named session belongs to the same person or bot. `sessions --json` lists
 local file presence only, without checking identity or authorization; `doctor --connect` shows user/bot type.
 Names use 1-32 lowercase ASCII letters/digits, underscores or hyphens, starting with letter/digit.

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/CHANGELOG.md

@@ -7,6 +7,12 @@ move them into a versioned section when publishing a release.
 
 No unreleased changes.
 
+## 0.5.0 - 2026-11-11
+
+- Show the delivery method chosen by Telegram during phone login.
+- Add `login --qr` for sign-in with an already authorized Telegram mobile app.
+- Pipeline up to four upload blocks per attachment to reduce time spent waiting for Telegram.
+
 ## 0.4.0 - 2026-10-25
 
 ### Added

{telegram_cli_local-0.4.0/telegram_cli_local.egg-info → telegram_cli_local-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telegram-cli-local
-Version: 0.4.0
+Version: 0.5.0
 Summary: Telegram CLI for user and bot accounts with named sessions
 Author: BYxarek
 License-Expression: Apache-2.0
@@ -18,6 +18,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Telethon==1.45.0
+Requires-Dist: qrcode==8.2
 Provides-Extra: fast
 Requires-Dist: cryptg<0.7,>=0.5.2; extra == "fast"
 Dynamic: license-file
@@ -325,6 +326,10 @@ tcli login
 It does not connect to Telegram. Run it again to replace credentials; invalid input leaves existing settings intact.
 
 `login` asks for your international phone number, Telegram login code, and 2FA password if enabled.
+The CLI displays the delivery method chosen by Telegram. If Telegram sends an in-app code,
+open the service chat named **Telegram** on an already signed-in device.
+If the code does not arrive, run `tcli login --qr` in a terminal and scan the QR code in the
+Telegram mobile app under **Settings → Devices → Link Desktop Device**.
 Code and password input is hidden. The session is saved for later commands.
 
 ### 3. Read and send
@@ -388,7 +393,7 @@ the CLI displays metadata. Deletion and inline media playback are not supported.
 | Command | Purpose |
 | --- | --- |
 | `tcli config` | Save or replace API credentials |
-| `tcli login` | Sign in to a user account; add `--bot` for a bot |
+| `tcli login` | Sign in by phone or with `--qr`; use `--bot` for a bot |
 | `tcli sessions --json` | List local named session files offline |
 | `tcli delete CHAT ID [ID ...]` | Delete the selected messages for everyone |
 | `tcli chats --limit 100` | List up to 100 chats; default: 50 |
@@ -569,7 +574,9 @@ For faster workflows, forward existing Telegram attachments instead of downloadi
 them again, use `--jsonl` for large history reads, and apply server-side date/sender/media filters
 before filename matching. Keep filename scan bounds as small as the task allows. Disable progress
 with `--no-progress` when measuring transfer speed. Avoid concurrent CLI processes on one session.
-Parallel transfers need separate measurement and careful FloodWait handling; they are not enabled.
+For local attachments larger than 512 KiB, `send --attach` keeps up to four 512 KiB blocks
+in flight over one Telegram connection. This also applies to individual files in an album.
+Progress counts acknowledged bytes, and the CLI submits the message after all its blocks are saved.
 Resumable downloads already use Telethon's maximum default request size (512 KiB).
 Plain text has no byte-transfer callback: the CLI reports the confirmed message ID after sending.
 

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/README.md

@@ -301,6 +301,10 @@ tcli login
 It does not connect to Telegram. Run it again to replace credentials; invalid input leaves existing settings intact.
 
 `login` asks for your international phone number, Telegram login code, and 2FA password if enabled.
+The CLI displays the delivery method chosen by Telegram. If Telegram sends an in-app code,
+open the service chat named **Telegram** on an already signed-in device.
+If the code does not arrive, run `tcli login --qr` in a terminal and scan the QR code in the
+Telegram mobile app under **Settings → Devices → Link Desktop Device**.
 Code and password input is hidden. The session is saved for later commands.
 
 ### 3. Read and send
@@ -364,7 +368,7 @@ the CLI displays metadata. Deletion and inline media playback are not supported.
 | Command | Purpose |
 | --- | --- |
 | `tcli config` | Save or replace API credentials |
-| `tcli login` | Sign in to a user account; add `--bot` for a bot |
+| `tcli login` | Sign in by phone or with `--qr`; use `--bot` for a bot |
 | `tcli sessions --json` | List local named session files offline |
 | `tcli delete CHAT ID [ID ...]` | Delete the selected messages for everyone |
 | `tcli chats --limit 100` | List up to 100 chats; default: 50 |
@@ -545,7 +549,9 @@ For faster workflows, forward existing Telegram attachments instead of downloadi
 them again, use `--jsonl` for large history reads, and apply server-side date/sender/media filters
 before filename matching. Keep filename scan bounds as small as the task allows. Disable progress
 with `--no-progress` when measuring transfer speed. Avoid concurrent CLI processes on one session.
-Parallel transfers need separate measurement and careful FloodWait handling; they are not enabled.
+For local attachments larger than 512 KiB, `send --attach` keeps up to four 512 KiB blocks
+in flight over one Telegram connection. This also applies to individual files in an album.
+Progress counts acknowledged bytes, and the CLI submits the message after all its blocks are saved.
 Resumable downloads already use Telethon's maximum default request size (512 KiB).
 Plain text has no byte-transfer callback: the CLI reports the confirmed message ID after sending.
 

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/README.ru.md

@@ -305,6 +305,10 @@ tcli --help
    неверный ввод не перезаписывает существующий файл.
 3. Выполните `tcli login`. Введите телефон в международном формате, код входа
    и пароль двухфакторной защиты, если она включена. Код и пароль вводятся скрыто.
+   CLI показывает способ доставки, выбранный Telegram. Если код отправлен в приложение,
+   откройте служебный чат **Telegram** на устройстве, где вы уже вошли в аккаунт.
+   Если код не приходит, запустите `tcli login --qr` в терминале и отсканируйте QR-код
+   в мобильном Telegram через **Настройки → Устройства → Подключить устройство**.
 4. Откройте список чатов и прочитайте нужный диалог:
 
 ```console
@@ -365,7 +369,7 @@ tcli download me 123 --output photo.jpg
 | `tcli` / `tcli help` | Показывает общую справку, первые шаги и примеры |
 | `tcli help send` | Показывает справку по конкретной команде |
 | `tcli config` | Сохраняет или заменяет API-данные |
-| `tcli login` | Вход в аккаунт пользователя; `--bot` для бота |
+| `tcli login` | Вход по телефону или через `--qr`; `--bot` для бота |
 | `tcli sessions --json` | Список локальных именованных сессий без сети |
 | `tcli delete CHAT ID [ID ...]` | Удаление выбранных сообщений для всех |
 | `tcli chats --limit 100` | Показывает до 100 чатов; по умолчанию — 50 |
@@ -552,7 +556,9 @@ Telethon автоматически использует установленн
 для большой истории и серверные фильтры даты, отправителя и типа медиа перед поиском по имени файла.
 Ограничивайте объём сканирования необходимым минимумом. Для замера скорости отключайте вывод
 через `--no-progress`. Избегайте одновременных процессов CLI с одной сессией.
-Параллельные передачи требуют отдельных замеров и обработки FloodWait; они не включены.
+Для локальных вложений больше 512 КиБ команда `send --attach` держит в работе до четырёх
+блоков по 512 КиБ через одно соединение с Telegram. Это действует и для файлов внутри альбома.
+Индикатор учитывает подтверждённые байты. CLI отправляет сообщение после сохранения всех блоков.
 Докачивание уже использует максимальный стандартный размер запроса Telethon — 512 КиБ.
 У обычного текста нет callback с количеством переданных байтов: после отправки CLI показывает
 подтверждённый ID сообщения.

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/RELEASING.md

@@ -34,7 +34,7 @@ python -X utf8 scripts/check_docs.py
 python -X utf8 -m unittest discover -s tests -v
 python -m build
 python -m twine check --strict dist/*
-python scripts/check_distribution.py dist/telegram_cli_local-0.4.0-py3-none-any.whl
+python scripts/check_distribution.py dist/telegram_cli_local-0.5.0-py3-none-any.whl
 ```
 
 Use a clean `dist/` directory for each release to avoid uploading stale versions.
@@ -49,7 +49,7 @@ It needs access to PyPI to install the wheel's dependencies; it never accesses T
    under `Unreleased` for every change; move those entries into a versioned section for the release.
 3. Commit and push to `main`. Wait for the `Test, build, and publish` workflow to pass on Windows
    and Linux with Python 3.10 and 3.14, including the built-wheel installation check.
-4. Create a GitHub Release targeting that commit with a matching tag, for example `v0.4.0`, and publish it.
+4. Create a GitHub Release targeting that commit with a matching tag, for example `v0.5.0`, and publish it.
    Draft releases do not upload. The workflow rejects tags that differ from the package version.
 5. Check that the publish job succeeded and that https://pypi.org/project/telegram-cli-local/
    lists the expected version. Test `pipx install telegram-cli-local` on a clean machine.

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/requirements.txt

@@ -1 +1,2 @@
 Telethon==1.45.0
+qrcode==8.2

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/tcli_skills/SKILL.md

@@ -43,7 +43,7 @@ If unavailable, inspect `tcli help`; do not assume newer commands exist based on
 | Cancel specific scheduled messages | `tcli scheduled me --cancel 123 124 --json` |
 | Download one attachment | `tcli download me 123 --output archive.zip --json` |
 | Configure API credentials locally | `tcli config` |
-| Sign in interactively in the user's terminal | `tcli login` |
+| Sign in interactively in the user's terminal | `tcli login` or `tcli login --qr` |
 | Check local setup, optionally connectivity | `tcli doctor` or `tcli doctor --connect` |
 | End this CLI session when requested | `tcli logout` |
 | Refresh supported agent skills offline | `tcli skills install --agent all` |
@@ -55,6 +55,8 @@ Use `thread` for the parent chain and `--around` for chronological neighbors; th
 ## Sessions, bots and deletion
 
 Select the authorized account with `--session NAME` before or after the command; default is `default`.
+Phone login reports where Telegram sent the code. If it does not arrive, run `tcli login --qr`
+in a terminal and scan it in Telegram mobile under Settings > Devices > Link Desktop Device.
 Do not assume a different named session belongs to the same person or bot. `sessions --json` lists
 local file presence only, without checking identity or authorization; `doctor --connect` shows user/bot type.
 Names use 1-32 lowercase ASCII letters/digits, underscores or hyphens, starting with letter/digit.

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/tcli_skills/__init__.py

@@ -1,3 +1,3 @@
 """Bundled agent skill installed by tcli skills install."""
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0/telegram_cli_local.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telegram-cli-local
-Version: 0.4.0
+Version: 0.5.0
 Summary: Telegram CLI for user and bot accounts with named sessions
 Author: BYxarek
 License-Expression: Apache-2.0
@@ -18,6 +18,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Telethon==1.45.0
+Requires-Dist: qrcode==8.2
 Provides-Extra: fast
 Requires-Dist: cryptg<0.7,>=0.5.2; extra == "fast"
 Dynamic: license-file
@@ -325,6 +326,10 @@ tcli login
 It does not connect to Telegram. Run it again to replace credentials; invalid input leaves existing settings intact.
 
 `login` asks for your international phone number, Telegram login code, and 2FA password if enabled.
+The CLI displays the delivery method chosen by Telegram. If Telegram sends an in-app code,
+open the service chat named **Telegram** on an already signed-in device.
+If the code does not arrive, run `tcli login --qr` in a terminal and scan the QR code in the
+Telegram mobile app under **Settings → Devices → Link Desktop Device**.
 Code and password input is hidden. The session is saved for later commands.
 
 ### 3. Read and send
@@ -388,7 +393,7 @@ the CLI displays metadata. Deletion and inline media playback are not supported.
 | Command | Purpose |
 | --- | --- |
 | `tcli config` | Save or replace API credentials |
-| `tcli login` | Sign in to a user account; add `--bot` for a bot |
+| `tcli login` | Sign in by phone or with `--qr`; use `--bot` for a bot |
 | `tcli sessions --json` | List local named session files offline |
 | `tcli delete CHAT ID [ID ...]` | Delete the selected messages for everyone |
 | `tcli chats --limit 100` | List up to 100 chats; default: 50 |
@@ -569,7 +574,9 @@ For faster workflows, forward existing Telegram attachments instead of downloadi
 them again, use `--jsonl` for large history reads, and apply server-side date/sender/media filters
 before filename matching. Keep filename scan bounds as small as the task allows. Disable progress
 with `--no-progress` when measuring transfer speed. Avoid concurrent CLI processes on one session.
-Parallel transfers need separate measurement and careful FloodWait handling; they are not enabled.
+For local attachments larger than 512 KiB, `send --attach` keeps up to four 512 KiB blocks
+in flight over one Telegram connection. This also applies to individual files in an album.
+Progress counts acknowledged bytes, and the CLI submits the message after all its blocks are saved.
 Resumable downloads already use Telethon's maximum default request size (512 KiB).
 Plain text has no byte-transfer callback: the CLI reports the confirmed message ID after sending.
 

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/telegram_cli_local.egg-info/requires.txt

@@ -1,4 +1,5 @@
 Telethon==1.45.0
+qrcode==8.2
 
 [fast]
 cryptg<0.7,>=0.5.2

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/tests/test_features.py

@@ -1,6 +1,7 @@
 """Offline contract tests for history, metadata, scheduling and safe transfers."""
 import asyncio
 import argparse
+import hashlib
 import io
 import json
 import sqlite3
@@ -376,6 +377,97 @@ class RpcTests(unittest.IsolatedAsyncioTestCase):
 class TransferTests(unittest.IsolatedAsyncioTestCase):
     execute = HistoryTests.execute
 
+    async def test_send_file_pipelines_parts_and_waits_for_all_acknowledgements(self):
+        client = tg.UploadClient(None, 12345, "synthetic")
+        peer = tg.types.InputPeerSelf()
+        block_size = 512 * 1024
+        for full_parts in (5, 20):
+            with self.subTest(full_parts=full_parts), TemporaryDirectory() as directory:
+                data = b"".join(bytes([index]) * block_size for index in range(full_parts)) + b"tail"
+                path = Path(directory) / "sample.bin"
+                path.write_bytes(data)
+                progress = []
+                saved = {}
+                first_window = asyncio.Event()
+                fifth_started = asyncio.Event()
+                active = peak = 0
+                big = full_parts == 20
+
+                async def rpc(request):
+                    nonlocal active, peak
+                    if isinstance(request, tg.functions.messages.SendMediaRequest):
+                        handle = request.media.file
+                        self.assertEqual(len(saved), full_parts + 1)
+                        self.assertEqual(handle.parts, len(saved))
+                        self.assertEqual(handle.name, path.name)
+                        self.assertEqual(b"".join(saved[index].bytes for index in range(handle.parts)), data)
+                        self.assertEqual({part.file_id for part in saved.values()}, {handle.id})
+                        if big:
+                            self.assertIsInstance(handle, tg.types.InputFileBig)
+                            self.assertTrue(all(part.file_total_parts == handle.parts for part in saved.values()))
+                        else:
+                            self.assertEqual(handle.md5_checksum, hashlib.md5(data).hexdigest())
+                        return object()
+
+                    method = tg.functions.upload.SaveBigFilePartRequest if big else tg.functions.upload.SaveFilePartRequest
+                    self.assertIsInstance(request, method)
+                    index = request.file_part
+                    active += 1
+                    peak = max(peak, active)
+                    if active == 4:
+                        first_window.set()
+                    if index == 4:
+                        fifth_started.set()
+                    await first_window.wait()
+                    if index == 0:
+                        await fifth_started.wait()
+                    saved[index] = request
+                    active -= 1
+                    return True
+
+                with path.open("rb") as stream, patch.object(tg.UploadClient, "__call__", side_effect=rpc), \
+                        patch.object(client, "get_input_entity", AsyncMock(return_value=peer)), \
+                        patch.object(client, "_get_response_message", return_value=fake_message(43)):
+                    message = await asyncio.wait_for(client.send_file(
+                        peer, stream, force_document=True, progress_callback=lambda sent, total: progress.append((sent, total))
+                    ), timeout=5)
+                self.assertEqual(message.id, 43)
+                self.assertEqual(peak, 4)
+                self.assertEqual(progress[-1], (len(data), len(data)))
+                self.assertEqual(progress, sorted(set(progress)))
+
+    async def test_upload_failure_cancels_pending_parts_without_sending_media(self):
+        client = tg.UploadClient(None, 12345, "synthetic")
+        peer = tg.types.InputPeerSelf()
+        ready = asyncio.Event()
+        started = []
+        cancelled = []
+        with TemporaryDirectory() as directory:
+            path = Path(directory) / "sample.bin"
+            path.write_bytes(b"x" * (5 * 512 * 1024))
+
+            async def rpc(request):
+                self.assertIsInstance(request, tg.functions.upload.SaveFilePartRequest)
+                index = request.file_part
+                started.append(index)
+                if len(started) == 4:
+                    ready.set()
+                if index == 0:
+                    await ready.wait()
+                    raise tg.FloodWaitError(request, capture=15)
+                try:
+                    await asyncio.Future()
+                finally:
+                    cancelled.append(index)
+
+            with path.open("rb") as stream, patch.object(tg.UploadClient, "__call__", side_effect=rpc), \
+                    patch.object(client, "get_input_entity", AsyncMock(return_value=peer)):
+                with self.assertRaises(tg.FloodWaitError) as error:
+                    await asyncio.wait_for(client.send_file(peer, stream, force_document=True), timeout=5)
+        self.assertEqual(error.exception.seconds, 15)
+        self.assertEqual(started, [0, 1, 2, 3])
+        self.assertCountEqual(cancelled, [1, 2, 3])
+
     async def test_batch_limits_and_preflight_before_writes(self):
         with TemporaryDirectory() as directory:
             client = FakeClient()

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/tests/test_tg.py

@@ -1,3 +1,4 @@
+import asyncio
 import unittest
 import json
 import os
@@ -96,7 +97,7 @@ class SkillsTests(unittest.TestCase):
     def test_install_both_is_offline_and_idempotent(self):
         with patch.dict(os.environ, {}, clear=True), patch("sys.argv", ["tcli", "skills", "install"]), \
                 patch("tg.sys.stdout.reconfigure"), patch("tg.sys.stderr.reconfigure"), \
-                patch("tg.TelegramClient") as client, patch("tg.agent_installed", return_value=True):
+                patch("tg.UploadClient") as client, patch("tg.agent_installed", return_value=True):
             self.assertEqual(tg.main(), 0)
             client.assert_not_called()
         tg.install_skills("all")
@@ -354,7 +355,7 @@ class ConfigTests(unittest.TestCase):
                 patch("tg.sys.stdout.reconfigure"), patch("tg.sys.stderr.reconfigure"), \
                 patch("builtins.input", return_value="12345"), \
                 patch("tg.getpass", return_value="a" * 32), \
-                patch("builtins.print"), patch("tg.TelegramClient") as client:
+                patch("builtins.print"), patch("tg.UploadClient") as client:
             self.assertEqual(tg.main(), 0)
         client.assert_not_called()
         self.assertEqual(tg.load_credentials(self.path), (12345, "a" * 32))
@@ -390,11 +391,18 @@ class FakeClient:
         self.download_media = AsyncMock()
         self.get_messages = AsyncMock(return_value=[])
         self.start = AsyncMock()
+        self.api_id, self.api_hash = 12345, "synthetic_hash"
+        self.request = AsyncMock()
+        self.sign_in = AsyncMock()
+        self.qr_login = AsyncMock()
         self.get_me = AsyncMock(return_value=SimpleNamespace(bot=False, first_name="User", id=1))
         self.log_out = AsyncMock()
         self.is_connected = Mock(return_value=False)
         self.session = SimpleNamespace(save=Mock())
 
+    async def __call__(self, request):
+        return await self.request(request)
+
     async def iter_dialogs(self, **kwargs):
         for dialog in self.dialogs:
             yield dialog
@@ -610,7 +618,7 @@ class CliTests(unittest.IsolatedAsyncioTestCase):
         client.is_user_authorized.return_value = False
         with patch("builtins.input", return_value="invalid"), self.assertRaisesRegex(ValueError, "international"):
             await tg.run(client, tg.parser().parse_args(["login"]))
-        client.start.assert_not_awaited()
+        client.request.assert_not_awaited()
         client.disconnect.assert_awaited_once()
 
     async def test_new_user_and_bot_login(self):
@@ -618,16 +626,64 @@ class CliTests(unittest.IsolatedAsyncioTestCase):
             client = FakeClient()
             client.is_user_authorized.return_value = False
             client.get_me.return_value.bot = bot
+            client.request.return_value = tg.types.auth.SentCode(
+                tg.types.auth.SentCodeTypeApp(5), "synthetic_code_hash")
+            secret = "123:synthetic_token" if bot else "12345"
+            errors = io.StringIO()
             with patch("builtins.input", return_value="+15551234567"), \
-                    patch("tg.getpass", return_value="123:synthetic_token"), patch.dict(os.environ, {}, clear=True), \
-                    patch("builtins.print"):
+                    patch("tg.getpass", return_value=secret), patch.dict(os.environ, {}, clear=True), \
+                    redirect_stdout(io.StringIO()), redirect_stderr(errors):
                 await tg.run(client, tg.parser().parse_args(["login", *(["--bot"] if bot else [])]))
             if bot:
                 client.start.assert_awaited_once_with(bot_token="123:synthetic_token")
             else:
-                self.assertEqual(client.start.await_args.kwargs["phone"], "+15551234567")
+                client.request.assert_awaited_once()
+                self.assertEqual(client.request.await_args.args[0].phone_number, "+15551234567")
+                client.sign_in.assert_awaited_once_with("+15551234567", code="12345", phone_code_hash="synthetic_code_hash")
+                self.assertIn("service chat named Telegram", errors.getvalue())
             client.disconnect.assert_awaited_once()
 
+    async def test_phone_login_does_not_prompt_for_firebase_sms(self):
+        client = FakeClient()
+        client.is_user_authorized.return_value = False
+        client.request.return_value = tg.types.auth.SentCode(
+            tg.types.auth.SentCodeTypeFirebaseSms(5), "synthetic_code_hash")
+        with patch("builtins.input", return_value="+15551234567"), patch("tg.getpass") as prompt:
+            with self.assertRaisesRegex(tg.CommandError, r"FirebaseSms.*login --qr"):
+                await tg.run(client, tg.parser().parse_args(["login"]))
+        prompt.assert_not_called()
+
+    async def test_email_login_submits_email_verification_code(self):
+        client = FakeClient()
+        client.is_user_authorized.return_value = False
+        client.request.side_effect = [
+            tg.types.auth.SentCode(tg.types.auth.SentCodeTypeEmailCode("a***@example.com", 5), "synthetic_hash"),
+            Mock(),
+        ]
+        with patch("builtins.input", return_value="+15551234567"), patch("tg.getpass", return_value="12345"), \
+                redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()) as stderr:
+            await tg.run(client, tg.parser().parse_args(["login"]))
+        self.assertIn("a***@example.com", stderr.getvalue())
+        sign_in = client.request.await_args.args[0]
+        self.assertEqual(sign_in.email_verification.code, "12345")
+        self.assertEqual(sign_in.phone_code_hash, "synthetic_hash")
+
+    async def test_qr_login_refreshes_expired_token_and_accepts_two_factor_password(self):
+        client = FakeClient()
+        client.is_user_authorized.return_value = False
+        qr = SimpleNamespace(url="tg://login?token=synthetic", recreate=AsyncMock(),
+                             wait=AsyncMock(side_effect=[asyncio.TimeoutError(),
+                                                        tg.errors.SessionPasswordNeededError(None)]))
+        client.qr_login.return_value = qr
+        with patch("tg.sys.stdout.isatty", return_value=True), patch("tg.QRCode") as image, \
+                patch("tg.getpass", return_value="synthetic_password"), patch("builtins.print"):
+            await tg.run(client, tg.parser().parse_args(["login", "--qr"]))
+        qr.recreate.assert_awaited_once()
+        self.assertEqual(qr.wait.await_count, 2)
+        self.assertEqual(image.return_value.print_ascii.call_count, 2)
+        client.sign_in.assert_awaited_once_with(password="synthetic_password")
+        client.disconnect.assert_awaited_once()
+
     async def test_bot_watch_uses_events_without_history_and_removes_handlers(self):
         client = FakeClient()
         client.is_bot.return_value = True
@@ -659,7 +715,7 @@ class MainTests(unittest.TestCase):
         self.output.reconfigure = lambda **kwargs: None
         self.errors.reconfigure = lambda **kwargs: None
         self.client = FakeClient()
-        self.factory = self.stack.enter_context(patch("tg.TelegramClient", return_value=self.client))
+        self.factory = self.stack.enter_context(patch("tg.UploadClient", return_value=self.client))
 
     def main(self, *args):
         with patch("sys.argv", ["tcli", *args]):

{telegram_cli_local-0.4.0 → telegram_cli_local-0.5.0}/tg.py

@@ -8,6 +8,9 @@ from contextlib import ExitStack
 from fnmatch import fnmatchcase
 from getpass import getpass
 from importlib.resources import files
+import inspect
+import io
+from itertools import islice
 import json
 import os
 from pathlib import Path
@@ -23,9 +26,10 @@ from http.client import HTTPException
 from urllib.request import Request, urlopen
 from urllib.parse import urlsplit
 
-from telethon import TelegramClient, events, utils
+from qrcode import QRCode
+from telethon import TelegramClient, errors, events, helpers, utils
 from telethon.errors import FloodWaitError, RPCError
-from telethon.tl import types, functions
+from telethon.tl import custom, types, functions
 from tcli_skills import __version__
 
 
@@ -41,6 +45,68 @@ class CommandError(ValueError):
         self.error_code = code
 
 
+class UploadClient(TelegramClient):
+    async def upload_file(self, file, *, part_size_kb=None, file_size=None, file_name=None,
+                          use_cache=None, key=None, iv=None, progress_callback=None):
+        part_size = 512 * 1024
+        # shortcut: pipeline seekable CLI attachments, extend when another input type needs parallel upload.
+        if (isinstance(file, (io.BufferedReader, io.BytesIO)) and isinstance(getattr(file, "name", None), str)
+                and file.seekable() and file.tell() == 0 and file_size is None and part_size_kb is None
+                and file_name is None and key is None and iv is None):
+            file_size = file.seek(0, os.SEEK_END)
+            file.seek(0)
+            if file_size > part_size:
+                return await self.upload_parts(file, file_size, part_size, progress_callback)
+        return await super().upload_file(file, part_size_kb=part_size_kb, file_size=file_size,
+                                         file_name=file_name, use_cache=use_cache, key=key, iv=iv,
+                                         progress_callback=progress_callback)
+
+    async def upload_parts(self, file, size, part_size, progress_callback):
+        file_id = helpers.generate_random_long()
+        part_count = (size + part_size - 1) // part_size
+        big = size > 10 * 1024 * 1024
+        digest = None if big else hashlib.md5()
+
+        async def save_part(index, data):
+            if big:
+                request = functions.upload.SaveBigFilePartRequest(file_id, index, part_count, data)
+            else:
+                request = functions.upload.SaveFilePartRequest(file_id, index, data)
+            if not await self(request):
+                raise CommandError("upload_failed", f"Telegram rejected upload block {index + 1} of {part_count}.")
+            return len(data)
+
+        parts = iter(range(part_count))
+        pending = set()
+        sent = 0
+        try:
+            while sent < size:
+                for index in islice(parts, 4 - len(pending)):
+                    length = min(part_size, size - index * part_size)
+                    data = file.read(length)
+                    if len(data) != length or (index == part_count - 1 and file.read(1)):
+                        raise CommandError("file_changed", "The attachment size changed during upload.")
+                    if digest is not None:
+                        digest.update(data)
+                    pending.add(asyncio.create_task(save_part(index, data)))
+                done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+                sent += sum(task.result() for task in done)
+                pending.difference_update(done)
+                if progress_callback is not None:
+                    result = progress_callback(sent, size)
+                    if inspect.isawaitable(result):
+                        await result
+        finally:
+            for task in pending:
+                task.cancel()
+            await asyncio.gather(*pending, return_exceptions=True)
+
+        name = os.path.basename(file.name)
+        if big:
+            return types.InputFileBig(file_id, part_count, name)
+        return custom.InputSizedFile(file_id, part_count, name, md5=digest, size=size)
+
+
 class CLIParser(argparse.ArgumentParser):
     def error(self, message):
         arguments = sys.argv[1:]
@@ -126,8 +192,10 @@ Help works without configuration or a Telegram login.''')
     commands.add_parser("config", help="Save API credentials locally",
                         description="Save or replace API_ID and API_HASH. No Telegram connection required.")
     login = commands.add_parser("login", help="Sign in to a user or bot account",
-                        description="Sign in with phone/code/2FA, or --bot with a hidden bot token or TG_BOT_TOKEN.")
-    login.add_argument("--bot", action="store_true", help="sign in with a bot token; API_ID/API_HASH are still required")
+                        description="Sign in with phone/code, --qr, or --bot. API_ID/API_HASH are required.")
+    login_modes = login.add_mutually_exclusive_group()
+    login_modes.add_argument("--bot", action="store_true", help="sign in with a hidden bot token or TG_BOT_TOKEN")
+    login_modes.add_argument("--qr", action="store_true", help="scan a terminal QR code from an already signed-in Telegram mobile app")
     sessions = commands.add_parser("sessions", help="List local session files offline; does not check authorization")
     sessions.add_argument("--json", action="store_true", help="output session names and paths as JSON")
     commands.add_parser("logout", help="Revoke this CLI session",
@@ -834,6 +902,79 @@ async def resolve_chat(client, value, bot=False):
     return matches[0]
 
 
+async def login_user_by_phone(client):
+    phone = input("Phone number with country code: ").strip()
+    if not re.fullmatch(r"\+[0-9]{7,15}", phone):
+        raise ValueError("Enter an international phone number, for example +15551234567.")
+    request = functions.auth.SendCodeRequest(phone, client.api_id, client.api_hash, types.CodeSettings())
+    for attempt in range(3):
+        try:
+            sent = await client(request)
+            break
+        except errors.AuthRestartError:
+            if attempt == 2:
+                raise
+
+    if isinstance(sent, types.auth.SentCodePaymentRequired):
+        raise CommandError("login_code_unavailable", "Telegram requires payment for code delivery. Try tcli login --qr.")
+    if isinstance(sent, types.auth.SentCodeSuccess):
+        return
+    delivery = sent.type
+    if isinstance(delivery, types.auth.SentCodeTypeApp):
+        destination = "the service chat named Telegram on an already signed-in device"
+    elif isinstance(delivery, (types.auth.SentCodeTypeSms, types.auth.SentCodeTypeSmsWord,
+                               types.auth.SentCodeTypeSmsPhrase)):
+        destination = "SMS"
+    elif isinstance(delivery, types.auth.SentCodeTypeCall):
+        destination = "a phone call"
+    elif isinstance(delivery, types.auth.SentCodeTypeEmailCode):
+        destination = f"email ({safe_text(delivery.email_pattern)})"
+    elif isinstance(delivery, types.auth.SentCodeTypeFragmentSms):
+        destination = f"Fragment ({safe_text(delivery.url)})"
+    else:
+        channel = type(delivery).__name__.removeprefix("SentCodeType")
+        raise CommandError("login_code_unavailable",
+                           f"Telegram requires {channel} verification. Try tcli login --qr.")
+    print(f"Telegram sent the login code via {destination}. If it doesn't arrive, try tcli login --qr.",
+          file=sys.stderr, flush=True)
+
+    for attempt in range(3):
+        code = getpass("Telegram login code: ").strip()
+        if code:
+            try:
+                if isinstance(delivery, types.auth.SentCodeTypeEmailCode):
+                    result = await client(functions.auth.SignInRequest(
+                        phone, sent.phone_code_hash, email_verification=types.EmailVerificationCode(code)))
+                    if isinstance(result, types.auth.AuthorizationSignUpRequired):
+                        raise CommandError("login_signup_required", "Create the account in the Telegram app first.")
+                else:
+                    await client.sign_in(phone, code=code, phone_code_hash=sent.phone_code_hash)
+                return
+            except (errors.PhoneCodeEmptyError, errors.PhoneCodeInvalidError, errors.CodeInvalidError):
+                pass
+            except (errors.PhoneCodeExpiredError, errors.PhoneCodeHashEmptyError) as error:
+                raise CommandError("login_code_expired", "Request a new code with tcli login or use tcli login --qr.") from error
+        if attempt < 2:
+            print("Invalid code. Please try again.", file=sys.stderr)
+    raise CommandError("login_code_invalid", "Three invalid code entries. Run tcli login again or use tcli login --qr.")
+
+
+async def login_user_by_qr(client):
+    if not sys.stdout.isatty():
+        raise CommandError("terminal_required", "Run tcli login --qr directly in an interactive terminal.")
+    qr = await client.qr_login()
+    while True:
+        print("On your phone, open Telegram > Settings > Devices > Link Desktop Device and scan:")
+        image = QRCode()
+        image.add_data(qr.url)
+        image.print_ascii(tty=True)
+        try:
+            await qr.wait()
+            return
+        except asyncio.TimeoutError:
+            await qr.recreate()
+
+
 async def run(client, args):
     try:
         await client.connect()
@@ -848,13 +989,27 @@ async def run(client, args):
                         raise ValueError("Invalid bot token format. Obtain a token from BotFather.")
                     await client.start(bot_token=token)
                 else:
-                    phone = input("Phone number with country code: ").strip()
-                    if not re.fullmatch(r"\+\d{7,15}", phone):
-                        raise ValueError("Enter an international phone number, for example +15551234567.")
-                    await client.start(phone=phone,
-                                       code_callback=lambda: getpass("Telegram login code: "),
-                                       password=lambda: getpass("Two-factor authentication password: "))
+                    try:
+                        if args.qr:
+                            await login_user_by_qr(client)
+                        else:
+                            await login_user_by_phone(client)
+                    except errors.SessionPasswordNeededError:
+                        for attempt in range(3):
+                            password = getpass("Two-factor authentication password: ")
+                            if password:
+                                try:
+                                    await client.sign_in(password=password)
+                                    break
+                                except errors.PasswordHashInvalidError:
+                                    if attempt == 2:
+                                        raise
+                            elif attempt == 2:
+                                raise ValueError("A two-factor authentication password is required.")
+                            print("Invalid password. Please try again.", file=sys.stderr)
             me = await client.get_me()
+            if me is None:
+                raise CommandError("unauthorized", "Telegram did not authorize this session. Try tcli login again.")
             if me.bot != args.bot:
                 raise CommandError("session_type_mismatch", "Account type does not match login mode; choose another --session.")
             print(f"Signed in as {'bot' if me.bot else 'user'} {safe_text(me.first_name)} (ID {me.id}).")
@@ -1336,8 +1491,8 @@ def main():
                 print("Use tcli doctor --connect to check Telegram connectivity and authorization.")
                 return 0
         session_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
-        client = TelegramClient(str(session_dir / "account"), api_id, api_hash,
-                                flood_sleep_threshold=0)
+        client = UploadClient(str(session_dir / "account"), api_id, api_hash,
+                              flood_sleep_threshold=0)
         asyncio.run(run(client, args))
     except KeyboardInterrupt:
         if getattr(args, "json", False):