npm - better-tg-cli - Versions diffs - 0.19.0 → 0.20.0 - Mend

better-tg-cli 0.19.0 → 0.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md CHANGED Viewed

@@ -1,211 +1,116 @@
 # better-tg-cli
-An unofficial, agent-friendly command-line client for Telegram on your own account (MTProto via `teleproto`, TL layer 229).
-The binary is `telegram`. Fork of [skillhq/telegram](https://github.com/skillhq/telegram) with bot
-buttons, rich (layer 228+) bot replies, threads and forum topics, compact output for agents, and
-about 60 commands. Run `telegram help-all` for the full command and flag list.
-## Installation
-```bash
-brew install thevilfer/tap/better-tg-cli   # standalone binary, macOS and Linux, no Node needed
+[![CI](https://github.com/TheVilfer/better-tg-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/TheVilfer/better-tg-cli/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/better-tg-cli?color=cb3837&logo=npm)](https://www.npmjs.com/package/better-tg-cli)
+[![Homebrew](https://img.shields.io/badge/brew-thevilfer%2Ftap-fbb040?logo=homebrew)](https://github.com/TheVilfer/homebrew-tap)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+An unofficial, agent-friendly command-line client for Telegram that runs **on your own account**
+(MTProto via [`teleproto`](https://www.npmjs.com/package/teleproto), TL layer 229). The command is
+`telegram`: about 60 commands for reading, searching, writing, bots, groups and exports, built so
+that AI agents (Claude Code, Codex, …) can drive it cheaply and safely.
+```console
+$ telegram inbox -n 3
+48 unread in 7 chats (showing 3)
+1234567890 user unread=2 Alice @alice | see you at 7?
+-1001234567 supergroup muted unread=41 Rust Moscow @rust_msk | anyone tried 1.90?
+-1009876543 channel unread=5 Changelog | v2.4 is out
+$ telegram read @alice -n 1 --json
+{"chatTitle":"Alice","messages":[{"id":812,"date":"2026-09-27T10:02:11.000Z","sender":"Alice","senderId":"1234567890","text":"see you at 7?"}]}
+```
+## Why this fork
+A fork of [skillhq/telegram](https://github.com/skillhq/telegram), reworked for agents:
+- **Current Telegram layer.** Bot replies with rich (layer 228+) content show real text instead of
+  `(no text)`. You can press bot buttons (`click`) and walk bot menus.
+- **Token-efficient output.** Off a TTY you get one compact line per item with the ID first, and
+  JSON on one line with empty fields dropped. `--max-text` trims long posts. `telegram help-all -g
+  <word>` prints every flag, generated from the code.
+- **Exact reads.** Real pagination for `--since/--until`, `--unread`, threads and channel
+  comments, forum topics, `get` by ID, search filters by type, sender or date, and `me` / `Избранное`
+  for Saved Messages.
+- **Safe by default.** The account is read-only until a human runs `write-access on [--for 1h]`
+  and confirms it in a terminal prompt or a macOS dialog, so an agent cannot switch it on itself.
+  Every write is logged to `~/.config/tg/audit.jsonl`. Secrets live in the macOS Keychain or in
+  1Password.
+- **Small and self-contained.** The npm package is one 0.3 MB file with zero runtime
+  dependencies. Homebrew installs a standalone binary with no Node.
+## Install
+```bash
+brew install thevilfer/tap/better-tg-cli   # standalone binary, macOS and Linux
 npm install -g better-tg-cli               # Node >= 20
 ```
-Both install the `telegram` command. To use it as an agent skill (Claude Code, Codex), clone the
-repo into the skills folder. That folder is the skill (`SKILL.md` + `reference.md`):
-```bash
-git clone https://github.com/TheVilfer/better-tg-cli.git ~/.agents/skills/telegram
-ln -s ~/.agents/skills/telegram ~/.claude/skills/telegram
-```
-To build from source you need Node >= 20 and [Bun](https://bun.sh) (the bundler):
-`npm install && npm run build && npm install -g .` (or `./install.sh`).
-### Updating
-`telegram update` updates the way it was installed: `brew upgrade`, `npm install -g better-tg-cli@latest`,
-or `git pull --ff-only` + build for a checkout. `telegram update --check` only reports.
-On a terminal the CLI checks npm once a day in the background and prints a one-line notice when a
-new version is out; piped output (agents) never gets it. `TG_NO_UPDATE_CHECK=1` turns it off.
-Hacking on the CLI: see [DEVELOPMENT.md](DEVELOPMENT.md) (run from source, isolated dev profile, debugger).
-Do **not** install `@skillhq/telegram`. That is the old upstream build on GramJS (layer 198), and
-bot replies show up as `(no text)`.
-**Linux note:** secrets go to the macOS Keychain or to 1Password (`telegram auth --op-vault`).
-Without either, the session is kept in `~/.config/tg/config.json5` (mode 0600), and write
-commands stay disabled.
-## Authentication
-**Your own API keys (default, for everyone):**
-1. Go to https://my.telegram.org/apps and log in with your phone number
-2. Create an application and copy its `api_id` and `api_hash`
-3. Run `telegram auth` and enter them, then your phone, the login code and your 2FA password
-**With an invite.** If the maintainer gave you an invite token, you don't need your own keys:
-```bash
-telegram auth --invite        # paste the token when asked (or: TG_INVITE=... / --invite -)
-```
-The invite service (`broker/`) hands out the app's keys once for your login. The `api_hash` is
-not stored on your machine afterwards, only the `api_id` and your session. Invites are personal,
-limited to a few logins, and can be revoked.
-Your session is stored in the macOS Keychain (service `tg-cli`), or in 1Password with
-`--op-vault`. `telegram logout` removes it.
-## Commands
-### Auth & Status
-```bash
-telegram whoami                              # Show logged-in account
-telegram check                               # Verify session/credentials
-```
-### Reading
-```bash
-telegram chats                               # List all chats
-telegram chats --type group                  # Filter by type (user, group, supergroup, channel)
-telegram read "MetaDAO Community" -n 50      # Read last 50 messages
-telegram read "MetaDAO" --since "1h"         # Messages from last hour
-telegram read @username -n 20                # Read DM with user
-telegram search "futarchy" --chat "MetaDAO"  # Search within chat
-telegram search "futarchy" --all             # Search all chats
-telegram inbox                               # Unread messages summary
-```
-### Writing
-```bash
-telegram send @username "Hello"              # Send DM
-telegram send "GroupName" "Hello everyone"   # Send to group
-telegram reply "ChatName" 12345 "Response"   # Reply to message ID
-```
-### Bot Buttons
+`telegram update` upgrades an existing install, whichever of these you used. On a terminal the CLI
+checks for new versions once a day. Agents and pipes never see that notice, and
+`TG_NO_UPDATE_CHECK=1` turns it off.
-```bash
-telegram buttons @SomeBot 12345              # List buttons on a message
-telegram click @SomeBot 12345 2              # Press button #2 (by index)
-telegram click @SomeBot 12345 "Settings"     # Press by label
-telegram click @SomeBot 12345 1 --json       # Machine-readable outcome
-```
+Do **not** install `@skillhq/telegram`. It is the old upstream build on GramJS (layer 198).
-Buttons show up inline in `read`/`inbox`/`search` output. After a callback
-press, `click` re-reads the message so you see the bot's edited reply and its
-new buttons — enough to navigate a bot's menus step by step. `click` needs
-write access enabled.
-### Reactions, Forwarding & Pinning
-```bash
-telegram react "ChatName" 12345 👍           # React with an emoji (--big, --remove)
-telegram reactions "ChatName" 12345          # List who reacted
-telegram forward "FromChat" 12345 "ToChat"   # Forward message(s); comma-separate IDs
-telegram pin "ChatName" 12345                # Pin (--notify to alert members)
-telegram unpin "ChatName" 12345              # Unpin one; omit ID to unpin all
-```
+### As an agent skill
-### Editing, Deleting, Polls & Formatting
+The repo itself is the skill (`SKILL.md` + `reference.md`):
 ```bash
-telegram edit "Chat" 12345 "new text"        # Edit your own message
-telegram delete "Chat" 12,13 --just-me       # Delete (revoke by default)
-telegram mark-read "Chat"                    # Clear unread badge
-telegram pinned "Chat"                       # List pinned messages
-telegram send @user "<b>hi</b>" --html       # HTML/Markdown formatting (--markdown)
-telegram send @user "later" --schedule 2h    # Schedule a message
-telegram poll "Chat" "Q?" A B C              # Send a poll
-telegram vote "Chat" 12345 2                 # Vote for option #2
-```
-### Real-time, Chats & Profile
-```bash
-telegram watch "Chat" -t 30                  # Stream new messages (timeout/limit required)
-telegram join @channel                       # Join (also invite links); leave/create-group/create-channel
-telegram archive "Chat"                      # Archive / unarchive; invite-link "Chat"
-telegram block @user                         # block/unblock; add-contact/del-contact
-telegram set-name "First" "Last"             # set-bio / set-username / set-avatar
-telegram avatar @user                        # Download avatar; inline @gif "cat"; stories @user
-```
-All of the above except reads (`reactions`, `pinned`, `watch`, `avatar`, `inline`, `stories`) are write operations and need write access enabled.
-### Contacts & Groups
-```bash
-telegram contact @username                   # Get contact info
-telegram members "GroupName"                 # List group members
-telegram admins "GroupName"                  # List admins only
-telegram groups                              # List all groups
-telegram groups --admin                      # Groups where you're admin
-telegram kick "GroupName" @username          # Remove a user from a group
-telegram promote "GroupName" @username       # Promote a member to admin
-telegram transfer-owner "GroupName" @username # Transfer ownership (prompts for 2FA password)
+git clone https://github.com/TheVilfer/better-tg-cli.git ~/.agents/skills/telegram
+ln -s ~/.agents/skills/telegram ~/.claude/skills/telegram
 ```
-> `transfer-owner` is irreversible and requires two-step verification on your account.
-> It works on supergroups/channels only, prompts for your 2FA password securely, and asks
-> you to retype the group name to confirm (`-y` skips the confirmation).
-### Muting
+## Log in
-```bash
-telegram mute "ChatName"                     # Mute forever
-telegram mute "ChatName" -d 1h              # Mute for 1 hour
-telegram mute @username -d 8h               # Mute DM for 8 hours
-telegram unmute "ChatName"                   # Unmute
-```
+**With your own API keys** (the default):
+1. Open https://my.telegram.org/apps, create an application, and copy its `api_id` and `api_hash`.
+2. Run `telegram auth` and enter them, then your phone number, the login code and your 2FA password.
-### Folders
+**With an invite.** If the maintainer gave you an invite token, you don't need your own keys.
+Run `telegram auth --invite` and paste the token, or pass it as `TG_INVITE=…` or `--invite -`. The
+invite service (`broker/`) hands out the app's keys once, for this login only. The `api_hash` is not
+kept on your machine. Invites are personal, allow a limited number of logins, and can be revoked.
-```bash
-telegram folders                             # List all folders
-telegram folder "Work"                       # Show chats in folder
-telegram folder-add "Work" "ProjectChat"     # Add chat to folder
-telegram folder-remove "Work" "ProjectChat"  # Remove chat from folder
-```
+The session is stored in the macOS Keychain (service `tg-cli`), or in 1Password with
+`--op-vault <vault>`. `telegram logout` removes it. On Linux without 1Password, the session is kept
+in `~/.config/tg/config.json5` (mode 0600) and write commands stay disabled.
-### Utilities
+## Usage
 ```bash
-telegram sync --days 7                       # Sync last 7 days to markdown
-telegram sync --chat "MetaDAO" --days 30     # Sync specific chat
-```
-## Output Formats
+telegram chats --type channel                 # one line per chat, ID first
+telegram read "Chat" --since 1h               # exact range, newest first (--asc to flip)
+telegram read @channel --thread 123           # comments under a post
+telegram search "invoice" --chat "Work" --type document
+telegram get "Chat" 812 813                   # exact messages by ID
+telegram download "Chat" 812                  # save the attached file
+telegram sync --chat "Chat" --output ./export --resume   # incremental markdown export
-All read commands support multiple output formats:
-```bash
-telegram chats --json                        # JSON (for scripts/AI)
-telegram read "Chat" --markdown              # Markdown format
-telegram inbox --plain                       # Plain text (no colors)
+telegram write-access on --for 1h             # a human confirms this
+printf '%s' "$text" | telegram send @alice -  # text from stdin, no quoting problems
+telegram reply "Chat" 812 "on it" --silent
+telegram click @SomeBot 4410 "Settings"       # press an inline button
 ```
-## Configuration
-Configuration is stored in `~/.config/tg/`:
-- `config.json` - API credentials and session
-- Session data is encrypted and stored securely
+Read commands take `--json`, and some also take `--markdown`. See all commands with
+`telegram help-all`. [reference.md](reference.md) covers the behaviour that the flag list can't
+explain: output shapes, threads, bot buttons, admin commands and troubleshooting.
 ## Development
-```bash
-npm install
-npm run build
-npm run dev                            # Watch mode
-```
+[DEVELOPMENT.md](DEVELOPMENT.md) covers:
+- running from source (`scripts/tg-dev`);
+- isolated dev profiles (`TG_PROFILE`) that never touch your real session;
+- Telegram test servers;
+- editor debugging and tests.
+Releases are cut by `scripts/release.sh patch|minor|major`. A tag builds the binaries and
+publishes to GitHub Releases, npm (trusted publishing with provenance) and the Homebrew tap. See
+[CONTRIBUTING.md](CONTRIBUTING.md).
 ## License
-MIT — see [LICENSE](LICENSE). Based on [skillhq/telegram](https://github.com/skillhq/telegram)
-by Derek Rein. Not affiliated with or endorsed by Telegram; "Telegram" is a trademark of its owner.
+MIT, see [LICENSE](LICENSE). Based on [skillhq/telegram](https://github.com/skillhq/telegram) by
+Derek Rein. Not affiliated with or endorsed by Telegram; "Telegram" is a trademark of its owner.
+Use it in line with the [Telegram API Terms of Service](https://core.telegram.org/api/terms).

package/SKILL.md CHANGED Viewed

@@ -11,7 +11,7 @@ description: Full-featured Telegram CLI on the user's own account — read, sear
 ## Rules
-- **Chat identifiers:** `me` means Saved Messages. A numeric ID is matched exactly (use the ID shown first in `chats`/`inbox`/`search` output). `@username` resolves exactly. Any other text matches chat titles by **substring**. For writes, use an ID or @username.
+- **Chat identifiers:** `me` means Saved Messages. A numeric ID is matched exactly (use the ID shown first in `chats`/`inbox`/`search` output). `@username` resolves exactly. For reads, any other text matches chat titles by **substring**. Writes accept only an exact, unique title and otherwise refuse, listing candidate IDs. Retry with the ID.
 - **Writes are off by default.** A write fails with "Write access is disabled". Only the user can turn writes on. `telegram write-access on --for 1h` shows them a confirmation dialog, which you cannot click yourself. Ask first, run it, and wait for their click. Get explicit approval for every message to other people and show the final text first.
 - **Save tokens:**
   - Start with `inbox --unmuted`, `chats -q <name>` or `search`, not a full `read`.