Telegram MCP para Claude Code
yashok111/telegram-mcp
Controle Claude do seu Telegram com multi-sessão e aprovações inline
Ver no GitHubServidor MCP que integra Claude Code com Telegram, permitindo controlar o Claude pelo celular. Fornece chat bidirecional, aprovação de ferramentas, execução de tarefas em background e gerenciamento de múltiplas sessões — tudo via binário único em Go, sem dependências de runtime Node/Bun.
Instalação
npx convez-ai yashok111/telegram-mcp1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Monitorar e guiar execuções do Claude Code remotamente pelo celular
- Aprovar/negar permissões de ferramentas (Bash, Edit, Read) via botões Telegram
- Disparar tarefas em background e receber atualizações em tempo real no Telegram
- Gerenciar múltiplas sessões Claude simultâneas com roteamento por alias
Veredito

Solução técnica sólida para controle remoto de Claude Code via Telegram, com suporte robusto a multi-sessão e aprovações. Restrição Linux-only limita o alcance; recomendado para usuários avançados que precisam de mobilidade e automação em escala.
README
A tradução para o português deste README ainda está na fila.
telegram-mcp
A local MCP server that bridges Claude Code and Telegram. Drive Claude from your phone: reply to messages, approve tool calls, kick off background runs, spawn fresh sessions — all over a single long-poller-backed bot.
Single Go binary. No node/bun runtime. Dies with its parent via
PR_SET_PDEATHSIG. State is a JSON file under
~/.claude/channels/telegram/.
Linux only. Uses Linux-specific kernel features (
PR_SET_PDEATHSIG,/proc/<pid>/commfor PID claim verification) and abstract unix sockets. Does not build or run on macOS or Windows.
Not affiliated with Anthropic. Replaces the bun-runtime
external_plugins/telegramplugin with a leak-free, kernel-anchored Go implementation.

Features
- Two-way chat — Claude Code replies arrive in Telegram, your messages
arrive back as MCP
notificationsand are routed to the right session. - Multi-session routing — every Claude Code session attaches as a shim
with its own
@s1/@s2/… alias. Address one or all via@s2 do X/@all status, or reply to a specific message to thread. - Forum-topic mode — point the bot at a supergroup with topics enabled
(
TELEGRAM_FORUM_CHAT_ID) and the daemon allocates one topic per session keyed by workdir/label, routes inbound from each topic to its owning shim, and auto-injectsmessage_thread_idon outbound. Replaces "which alias is talking?" with one tab per project. - Permission approvals — when Claude Code asks to run a Bash/Edit/Read
tool, an inline-button card lands in your DM:
✅ Allow,❌ Deny,⏳ Allow 1h,♾ Always,🚫 Always deny. Rules are remembered with TTL. - Background tasks (
/bg) — DM the bot a prompt; it forksclaude --printin any working directory, streams progress edits, sends the final answer when done. Per-user rate limits, hard timeouts, cancellation. - Daemon-spawned sessions (
/spawn) — DM/spawn --in <dir>and the daemon forks a fresh Claude Code client in that directory, hands you back a new@sNalias to talk to. - Per-chat effort (
/effort) —/effort low|medium|high|xhigh|max|ultrasets the model and thinking-token budget used by future/spawnand/bgruns from that chat (ultra= Claude Fable 5). Persisted across daemon restarts. - Live status feedback — while the agent works the daemon keeps a "typing…" bubble alive and rotates a reaction emoji on your message; in forum mode each topic carries a pinned header showing the owning session's state (🟢 idle · 🟡 busy · 🔵 awaiting permission · ⚪ disconnected), workdir, label, and uptime.
- Admin-agent (optional) — set
TELEGRAM_ADMIN_ENABLE=1and the daemon forks a persistent Claude-powered supervisor (@admin) that answers operator DMs with full tooling, surfaces anomalies (error bursts, spawn failures), and produces a daily digest. Autonomous reactions are sandboxed to read-only + propose-only. - MarkdownV2 output — opt-in formatted replies, bold/italic/code/spoiler.
- Local-only, single-user — no webhook, no public ingress, no DB. Long polling behind any NAT.
How it works
Claude Code session ─┐ ┌─ Telegram Bot API
│ │
(stdio MCP) │ │ (HTTPS long-poll)
▼ │
┌──────────────┐ IPC (unix sock) ┌─────────┴──────────┐
│ shim │ ◄──────────────► │ daemon │
│ (per CC pid)│ │ (one per host) │
└──────────────┘ │ - bot token │
│ - access gate │
│ - shim router │
└────────────────────┘
- Shim — stdio MCP plugin Claude Code launches. Holds no token. Speaks
IPC to the daemon. Tied to its parent CC process by
PR_SET_PDEATHSIG. - Daemon — one per host. Owns the bot token, runs the long-poller, holds the allowlist gate, routes inbound messages to the right shim. Auto-spawned by the first shim that needs it, or run permanently under systemd.
A single Telegram message can be routed by:
- Forum topic — when forum mode is on, a message inside a topic owned by a shim routes to that shim exclusively (mentions/reply-to inside the topic are ignored — the topic is the address).
- Reply-to — Telegram's reply UI threads the message to whichever shim sent the original.
- Mention —
@s2,@all, or@<label>if the shim was labeled. - Chat affinity — last shim that talked in the chat wins (with TTL).
- LRU fallback — most-recently-connected shim.
Quick start
1. Build
git clone https://github.com/yashok111/telegram-mcp.git
cd telegram-mcp
make build # → bin/telegram-mcp
Requires Linux and Go 1.26. macOS/Windows are not supported — the
daemon/shim lifecycle depends on PR_SET_PDEATHSIG and /proc/<pid>/comm.
Optional: make lint needs golangci-lint v2 built with Go 1.26 —
go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest.
2. Create a bot
Talk to @BotFather on Telegram, run /newbot,
collect the token.
mkdir -p ~/.claude/channels/telegram
echo 'TELEGRAM_BOT_TOKEN=123456:AA...' > ~/.claude/channels/telegram/.env
chmod 600 ~/.claude/channels/telegram/.env
3. Register with Claude Code
claude mcp add telegram -s user -- $(pwd)/bin/telegram-mcp
If the marketplace bun plugin is enabled, disable it first to avoid 409s fighting over the same token:
claude plugin disable telegram
Restart the Claude Code session.
4. Launch Claude Code with dev channels enabled
Telegram inbound is delivered as notifications/claude/channel/* — an
experimental MCP capability that Claude Code only honors when launched with
--dangerously-load-development-channels. Without the flag the daemon and
shim both log successful delivery, but the LLM never sees the message.
Add a shell alias and use it whenever you want a Telegram-aware session:
# ~/.zshrc or ~/.bashrc
alias claude-tg='claude --dangerously-load-development-channels plugin:telegram@local-yakov'
Then launch with claude-tg instead of claude. The plugin:telegram@local-yakov
arg is harmless for the MCP-server install path (it loads nothing extra) and
is required for /spawn-launched sessions where the bot forks a fresh CC
that needs the plugin name to match.
5. Pair your account
On first run the daemon prints a pairing code. DM the bot from your real
Telegram account with that code; the daemon adds you to the allowlist in
access.json. Run /telegram:access (skill bundled in the project) for the
managed pairing flow.
Forum-topic mode (optional)
Instead of every Claude Code session sharing the bot's single DM, point
the bot at a supergroup with topics enabled and get one topic per
session — one tab per project, persistent across /exit/restart.
Setup
-
In Telegram: New Group → add the bot → group settings → enable Topics.
-
Add the bot as Administrator with Manage Topics permission.
-
Get the chat id (any inbound from the group is logged in
daemon.logaschat_id=-100…). -
Add the chat id to
~/.claude/channels/telegram/.env:echo 'TELEGRAM_FORUM_CHAT_ID=-1002…' >> ~/.claude/channels/telegram/.env -
Restart the daemon. Every new
claude-tgsession triggerscreateForumTopicon hello, names it@s<N> — <workdir-basename>, and binds the shim.
Behavior
- Outbound — every
reply/react/edit_messagefrom a bound shim auto-fillsmessage_thread_id. Replies land in the shim's topic. - Inbound inside a topic — routed to that topic's owning shim
exclusively.
@all, mentions, and reply-to are ignored — the topic itself is the address. - Inbound in General (
thread_id=0) — routed by mention / reply / LRU exactly as before.@allstill broadcasts. - Permission prompts — for shims with a topic, the prompt card lands in the topic next to the tool output that triggered it (not in DM).
- Pinned header — each topic gets a pinned status message the daemon
maintains in place: owning alias, state icon (🟢 idle · 🟡 busy ·
🔵 awaiting permission · ⚪ disconnected · 🔴 closed), workdir, label,
last activity, and uptime. Toggle with
TELEGRAM_TOPIC_HEADER=0.
Persistence and reuse
Topics are kept when you /exit. The shim's lock drops; the topic
mapping in access.json stays. Next CC session in the same workdir (or
with the same --label) re-attaches to the existing topic, history
intact. Reuse key priority:
label:<L>if/labelwas set on the shim.workdir:<path>when workdir ≠$HOME(random shell sessions from$HOMEget fresh topics, not a shared bucket).- Otherwise a fresh topic.
Dead topics are reaped automatically. A topic whose owner disconnected
is closed after TELEGRAM_TOPIC_ORPHAN_AFTER (default 12h) of idleness;
a duplicate topic (a second concurrent session in the same workdir) is
closed within the hour once its session leaves; /topic close does it on
demand. Closed topics are then deleted by a background sweep after
TELEGRAM_TOPIC_PURGE_AFTER (default 12h) — so a dead topic fully
disappears within ~24h. Raise either env var to keep topics around longer
(reattaching to a still-open topic preserves its history).
/topic commands
| Command | Where | Effect |
|---|---|---|
/topic | inside a topic | Show owner alias / label / workdir / connected timestamp. |
/topic close | inside a topic | Kill the owning shim, close the topic, queue for purge. |
/topic rename <n> | inside a topic | Rename via editForumTopic (128-rune cap, pre-flighted). |
/topics list | DM | Render every known topic + lock state (admin-only). |
MCP tools exposed to Claude Code
| Tool | Purpose |
|---|---|
reply | Send text/files to a chat. Auto-chunks at 4096 chars. |
react | Set/clear emoji reaction on a message. |
edit_message | Edit a previously-sent message in place. |
download_attachment | Fetch a file_id into ~/.claude/channels/telegram/inbox/. |
telegram_peers | List other shims connected to this daemon. |
Telegram commands (DM the bot)

| Command | Effect |
|---|---|
/start, /help | Intro / command reference. |
/status | This chat's pinned shim, effort, and daemon health. |
/sessions | Status board of all connected shims. |
/use <prefix> / /pin <prefix> | Pin this chat to a shim by shim_id prefix. |
/unpin | Drop this chat's shim pin. |
/label <name> | Give your shim an @<name> alias. |
/effort <level> | Set model + thinking budget (low…max, show, clear) for future /spawn+/bg. |
/idle | Show how long the daemon has been idle. |
/rules list | Show active auto-approve rules with TTL. |
/rules clear | Drop all rules. |
/rules revoke <id> | Drop a single rule. |
/bg <prompt> [--in <dir>] | Spawn a one-shot claude --print background run. |
/bg list | List in-flight /bg tasks. |
/bg cancel <id> | SIGTERM a /bg task. |
/spawn [--in <dir>] | Fork a fresh Claude Code client in <dir>. |
/spawn list | List daemon-spawned sessions. |
/spawn cancel <id> | Terminate a spawn. |
/reaction <emoji> | Set the default ack reaction. |
/topics | DM-only: list every known forum topic (forum mode). |
Persistent daemon (optional)
The daemon auto-spawns on first use and idles out 7 days after the last shim
disconnects (override with TELEGRAM_DAEMON_IDLE_EXIT). To keep it alive
across reboots, install the user-mode systemd unit:
mkdir -p ~/.config/systemd/user
cp contrib/systemd/telegram-mcp.service ~/.config/systemd/user/
systemctl --user daemon-reload
systemctl --user enable --now telegram-mcp.service
loginctl enable-linger "$USER" # survive logout
enable-linger is not optional on headless servers. Without it,
systemd-logind reaps the user manager (and every --user unit, including
this one) seconds after your last ssh session closes — SpawnRunner.Stop()
fires on shutdown and kills every live /spawn along with the daemon. With
linger enabled, the user manager persists across logout and reboot so
long-running spawns survive an ssh disconnect. Check with
loginctl show-user "$USER" | grep Linger.
See contrib/systemd/README.md.
Configuration
State directory: ~/.claude/channels/telegram/ (override with
TELEGRAM_STATE_DIR).
| File | Purpose |
|---|---|
.env | TELEGRAM_BOT_TOKEN=... (chmod 0600). |
access.json | Allowlist, pairing state, group policy, UX prefs, per-chat effort. With forum mode: forum_chat_id, topics_by_thread, topics_by_reuse_key, closed_topics. |
daemon.sock | IPC socket (0600). |
daemon.pid | Daemon's claim PID (comm-checked). |
daemon.log | Daemon stderr when shim-spawned (else journalctl). |
inbox/ | Downloaded attachments (swept after TELEGRAM_INBOX_TTL). |
sessions/ | Per-shim session snapshots for self. |
shims/ | Per-shim log files (when shim-log sink enabled). |
Knobs (env vars, all optional):
| Variable | Default | Notes |
|---|---|---|
TELEGRAM_BOT_TOKEN | — | From BotFather. Required. |
TELEGRAM_STATE_DIR | ~/.claude/channels/telegram | State root. |
TELEGRAM_ACCESS_MODE | dynamic | static freezes access.json at boot. |
TELEGRAM_DAEMON_IDLE_EXIT | 604800 (7 days) | Idle exit seconds. 0 or negative disables. |
TELEGRAM_PREFIX_ALIAS | 1 | Inject @sN: source-alias prefix. |
TELEGRAM_FORUM_CHAT_ID | — | Supergroup id (-100…). Set to enable forum-topic mode. |
TELEGRAM_TOPIC_ORPHAN_AFTER | 12h | Idle time before a disconnected topic is auto-closed. 0 disables. |
TELEGRAM_TOPIC_PURGE_AFTER | 12h | Wait before background sweep deletes a closed topic. |
TELEGRAM_BG_MAX_PARALLEL | 3 | Concurrent /bg tasks per host. |
TELEGRAM_BG_TIMEOUT | 30m | Hard cap per /bg task. |
TELEGRAM_BG_DEFAULT_WORKDIR | $HOME | Fallback for /bg --in. |
TELEGRAM_BG_RATE_PER_HOUR | 10 | Per-user /bg rate. |
TELEGRAM_BG_CLAUDE_BIN | auto (see below) | /bg driver binary. |
TELEGRAM_SPAWN_MAX_PARALLEL | 3 | Concurrent /spawn sessions. |
TELEGRAM_SPAWN_HARD_TIMEOUT | 24h | Absolute cap per spawn. |
TELEGRAM_SPAWN_IDLE_TIMEOUT | 4h | Idle cap. 0 disables. |
TELEGRAM_SPAWN_DEFAULT_WORKDIR | $HOME | Fallback for /spawn --in. |
TELEGRAM_SPAWN_RATE_PER_HOUR | 5 | Per-user /spawn rate. |
TELEGRAM_SPAWN_CLAUDE_BIN | auto (see below) | /spawn driver binary. |
TELEGRAM_SPAWN_CLAUDE_ARGS | auto (see below) | Args appended after …_CLAUDE_BIN. |
TELEGRAM_FORUM_AUTOSPAWN_DISABLE | 0 (enabled) | Disable auto-spawning a session into an unowned forum topic. |
TELEGRAM_FORUM_AUTOSPAWN_COOLDOWN | 90s | Min interval between auto-spawns into the same topic. |
TELEGRAM_TOPIC_HEADER | 1 (on) | Pinned per-topic status header (forum mode). |
TELEGRAM_TOPIC_HEADER_REFRESH | 5s | Min interval between header edits (debounce). |
TELEGRAM_TOPIC_HEADER_TICK | 60s | Background uptime/idle re-render cadence. |
TELEGRAM_TYPING_REFRESH | 1 (on) | Set 0 to disable the "typing…" + reaction tracker. |
TELEGRAM_TYPING_TTL | 60 | Seconds a chat stays pending without an outbound. |
TELEGRAM_TYPING_ROTATION_EMOJIS | 👀,🤔,✍ | Reaction cycle while thinking; empty disables rotation. |
TELEGRAM_TYPING_DONE_EMOJI | 👌 | Reaction swapped in on first reply; off/empty suppresses. |
TELEGRAM_INBOX_TTL | 168h (7d) | Retention for downloaded attachments before sweep. |
TELEGRAM_CORRUPT_TTL | 168h (7d) | Retention for corrupt/unreadable inbox files. |
TELEGRAM_SESSIONS_TTL | 1h | Retention for stale session snapshots after exit. |
TELEGRAM_LOG_MAX_BYTES | 10485760 (10 MiB) | daemon.log rotation threshold; 0 disables. |
TELEGRAM_SHIM_LOG_DISABLE | 0 (sink on) | Disable per-shim log files under shims/. |
TELEGRAM_SHIM_LOG_MAX_BYTES | 2097152 (2 MiB) | Per-shim log rotation threshold; 0 disables. |
TELEGRAM_SHIM_LOG_TTL | 168h (7d) | Retention for per-shim logs after disconnect. |
TELEGRAM_ADMIN_ENABLE | 0 (off) | Fork the persistent admin-agent supervisor. |
TELEGRAM_ADMIN_MODEL | claude default | --model for admin-agent invocations. |
TELEGRAM_ADMIN_DENY_TOOLS | — (none) | Comma-separated admin mutation tools to hard-reject. |
TELEGRAM_ADMIN_MUTATE_RATE_PER_HOUR | 60 | Global cap on admin-agent mutations per hour. |
TELEGRAM_ADMIN_PENDING_TTL | 5m | How long a Tier-3 owner-confirm request waits. |
TELEGRAM_ADMIN_SITREP_INTERVAL | 24h | Daily digest cadence; 0 disables. |
TELEGRAM_ADMIN_ERRBURST_THRESHOLD | 20 | ERROR records in the window that trigger an anomaly; ≤0 disables. |
TELEGRAM_ADMIN_ERRBURST_WINDOW | 1m | Sliding window for error-burst counting. |
TELEGRAM_ADMIN_ERRBURST_COOLDOWN | 5m | Min interval between error-burst anomaly pings. |
Auto-resolve. When
TELEGRAM_{SPAWN,BG}_CLAUDE_BINis unset the daemon triesexec.LookPath("claude")first, then falls back to~/.nvm/versions/node/*/bin/claude(newest by mtime) — so the daemon keeps working across Node version bumps and inside systemd-launched processes whosePATHlacks the nvm dir. WhenTELEGRAM_SPAWN_CLAUDE_ARGSis unset the daemon scans~/.claude/plugins/marketplaces/*/.claude-plugin/marketplace.jsonfor marketplaces that publish atelegramplugin and have a corresponding installed-plugin dir at~/.claude/plugins/data/telegram-<channel>. The most recently used install wins (bydata/mtime —marketplace.jsonmtime is unreliable because Claude Code background-refreshes manifests). The resolved value is logged at daemon startup as"spawn claude args resolved". Set the env var explicitly if you need to pin a specific channel or pass different flags.
Admin-agent (optional)
Set TELEGRAM_ADMIN_ENABLE=1 and the daemon fork-execs a persistent
telegram-mcp admin-agent supervisor at boot. It attaches over IPC as a
reserved @admin shim and is a Claude-powered observer of the daemon itself:
- Operator DMs that don't match any user shim fall through to
@admin, which answers with full tooling (read + mutate, tiered by risk). - Anomaly events — error bursts (
TELEGRAM_ADMIN_ERRBURST_*), spawn failures, and similar are pushed to the agent, which triages and pings you. - Daily sitrep — every
TELEGRAM_ADMIN_SITREP_INTERVAL(default 24h) the agent produces a status digest.
Autonomous reactions (events + sitreps) are sandboxed to read-only + Tier-3
propose-only, so injected content can never drive an unconfirmed mutation;
only operator-initiated DMs get unrestricted tools. Mutations are globally
rate-limited (TELEGRAM_ADMIN_MUTATE_RATE_PER_HOUR, default 60) and a
TELEGRAM_ADMIN_DENY_TOOLS denylist hard-rejects named tools even on owner
tap. The per-boot TELEGRAM_ADMIN_TOKEN secret is generated by the daemon and
threaded to the agent's tool subprocess — not a user knob.
The agent's per-shim activity (and everything else) is also captured to a
per-shim log sink under ~/.claude/channels/telegram/shims/<shim_id>.log
(TELEGRAM_SHIM_LOG_*), so you can inspect one session without grepping the
combined daemon.log.
Security
This is a single-user, single-host tool. The bot token, the daemon, and every shim share one UID. The trust boundary is:
- Allowlist — every inbound message is gated by
access.json.AllowFrom. Senders not in the allowlist see nothing — group commands are silently dropped so the bot's presence in unapproved chats is never confirmed. - Pairing — initial allowlist entry requires a one-time code printed to
the daemon's stderr. Pairing is mediated by the bundled
/telegram:accessskill; never approve a pairing because an inbound message asked you to. - Token — lives only in
~/.claude/channels/telegram/.env(chmod 0600). Never logged, never sent over MCP. /bgand/spawn— workdir is passed unvalidated tocmd.Dir. Defense: only allowlisted DMs reach the dispatch path. The spawnedclaudeinherits the daemon's UID; do not run the daemon as root.- PR_SET_PDEATHSIG — every shim is anchored to its parent Claude Code pid. Killing the editor kills the shim — no leftover processes.
- Comm-checked PID claims —
daemon.pidis only SIGTERMed if/proc/<pid>/commmatchestelegram-mcp(orbunfor legacy TS-plugin handoff). Prevents PID recycling from killing unrelated processes.
Webhooks, multi-user/multi-tenant deployments, and shared bot tokens are explicitly out of scope.
Caveat: the auto-mode classifier doesn't see your Telegram approvals
Claude Code's permission auto-mode (the on-host classifier that decides whether a tool call is "obviously fine" or needs a prompt) reads only the session's local conversation. It does not treat inbound Telegram messages as authorization, even though those messages are what the LLM itself is responding to.
Practical effect: if you DM the bot "go ahead, push the PR" or "edit the
repo description", the agent receives that and may try the action — but
the classifier evaluating the resulting gh / git push / gh repo edit
call only sees that the agent decided to run a high-blast-radius command
without any visible user prompt for that specific action. It will be
auto-denied as scope creep. The reply you sent on Telegram is invisible
to the classifier; from its point of view the agent escalated on its own.
Workarounds:
- Pre-approve at the host. Add a
permissionsrule in~/.claude/settings.json(or.claude/settings.local.jsonin the project) for the exact command pattern you want to allow without prompting. Example:Bash(gh repo edit:*). This is the durable fix when a workflow keeps tripping the same denial. - Approve from the host TTY when prompted. If you're sitting at the editor, the classifier surfaces a prompt locally and you can approve there — the Telegram-side conversation continues unaffected.
- Narrow the scope. Phrase requests so the next tool call falls inside what was already authorized. "Update the README and open a PR" is in scope; "and while you're at it, edit the repo description" is a second action the classifier will judge on its own merits.
This is a property of Claude Code's permission model, not of this project. The trade-off is intentional: the classifier is conservative specifically because it cannot verify the provenance of messages reaching the LLM. Treat Telegram as a remote control with a brake.
Development
make build # bin/telegram-mcp
make test # go test -race ./...
make lint # golangci-lint v2
make lint-fix # auto-fix (modernize, gofumpt, intrange, etc.)
make check # lint + race-enabled test + build (CI gate)
Install the pre-commit hook so every commit gates on make check:
bash scripts/install-hooks.sh
Layout (eight packages, strict import discipline — see
CLAUDE.md for the import graph):
cmd/server/ entry + mode dispatch (daemon|shim|self)
internal/access/ allowlist + auto-approve rules + atomic save
internal/bot/ telego long-poller, handlers, outbound API
internal/chunk/ 4096-cap message splitter
internal/daemon/ bot-owning process, routing, /bg, /spawn
internal/ipc/ shim↔daemon JSON-RPC over unix socket
internal/mcp/ stdio MCP server + tool registry
internal/shim/ per-CC-session process, IPC client
Testing: goleak in every package's TestMain. ~84% project LOC
coverage across 1179 tests. No t.Parallel() — tests share httptest servers
and env vars. New code without a test gets pushback unless it's wiring in
cmd/server.
Comparison to the bun plugin
The marketplace external_plugins/telegram plugin ships as a server.ts
under bun. The Go port:
- Removes the runtime — single static binary, no
bun, nonode. - Anchors to parent at the kernel level —
PR_SET_PDEATHSIGmeans a killed editor cannot leave a busy-looping grandchild. - Separates concerns — bot token lives in one long-running daemon, not in every per-session shim. Multiple Claude Code sessions share one bot.
- Adds multi-session routing — alias + mention + reply-to + chat affinity. The bun version had no notion of "which session does this message belong to."
- State directory is drop-in compatible —
~/.claude/channels/telegram/layout is identical; existingaccess.jsonpairings carry over.
License
MIT © Yakov Kurbatov