hamen/claude-code-telegram: The Telegram Bridge That Makes Claude Interruptible
Remote access is the obvious feature. The real invention is a stop lane that can jump the queue while Claude stays sandboxed, redacted, and stateful.
- This repo treats interruption as the primary UX of remote Claude supervision, not as an edge case.
- StopAwareUpdateProcessor gives stop updates a fast lane that bypasses the normal sequential lock.
- Secret redaction, sandboxing, and audit logging make the bridge safe enough to act like a control plane.
- The project points beyond chat toward persistent, multi-project orchestration around Claude Code.
The stop button is the product
Remote access is easy to sell and easy to misunderstand. Sending Claude a prompt from your phone is not the hard part. The hard part is deciding what happens when the agent is still running, you are nowhere near the terminal, and the next message needs to cut in front of everything else.
That is why hamen/claude-code-telegram reads less like a chat wrapper and more like a control plane. It keeps active work visible, lets the user intervene, and preserves session state instead of treating every interruption as a reset.
How a stop command skips the line
The technical trick lives in StopAwareUpdateProcessor. Ordinary Telegram updates flow through the sequential lane behind a lock. A message that starts with stop: bypasses that gate, reaches the active request controller, and halts the running Claude task without waiting for the queue to drain.
That design matters because a stop command that arrives late is barely a stop. Priority routing turns interruption into a first-class path, which is the difference between a responsive agent and a polite one.
Safety makes preemption usable
Preemption only works if the surrounding guardrails are serious. The repo pairs the queue bypass with a SecurityValidator that constrains work to an approved directory, secret redaction that strips obvious credentials before they reach Telegram, and audit logging that records what happened without leaking what should stay private.
That mix changes the feel of the system. Claude can run bash, but it does so inside a bounded workspace, with the operator seeing a sanitized trace instead of raw shell fallout.
The origin story is useful because it explains the product direction. This began as a bridge, but the repo now points toward a broader operator surface: model switching, project-aware threads, persistent state, and an event-driven core that can grow beyond one chat stream.
Telegram is the doorway, not the boundary. The deeper pattern is a workflow system that lets a human supervise Claude without being glued to the terminal.
Compared with other ways to drive Claude
| Project | Access model | Interruptibility | Persistence | Security posture | Best use case |
|---|---|---|---|---|---|
| Terminal-only Claude Code | Local terminal | Manual, local | Whatever the shell keeps alive | Depends on the operator | Desk-bound solo work |
| Official remote control | Phone approval for a live session | Approval focused, not queue-aware | Session stays anchored to the terminal | Built in, narrow surface | Quick approvals from the mobile app |
| Other Telegram bridges | Chat bridge or tmux wrapper | Usually message order, not priority aware | Often custom persistence | Varies by DIY setup | Simple remote chat with Claude |
| hamen/claude-code-telegram | Telegram control plane with stop lane | Priority stop path via StopAwareUpdateProcessor | Persistent project threads and stored state | Sandboxing, redaction, audit logging | Supervise Claude from anywhere |
The comparison reveals the real niche. This repo is strongest where the pain is operational, not conversational: stopping a run, keeping context, and trusting the output enough to leave your desk.
