claude-telegram-bot 0.1.0__tar.gz

claude_telegram_bot-0.1.0/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(uv run:*)"
+    ]
+  }
+}

claude_telegram_bot-0.1.0/.env.example

@@ -0,0 +1,7 @@
+BOT_TOKEN=your-telegram-bot-token
+ADMIN_USER_ID=123456789
+ALLOWED_USER_IDS=123456789,987654321
+CLAUDE_PATH=/home/zhangchi/.local/bin/claude
+CLAUDE_TIMEOUT=120
+MAX_HISTORY_MESSAGES=40
+# DATA_DIR defaults to ./data (relative to project root)

claude_telegram_bot-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+.env
+data/
+.idea/
+.vscode/
+*.log

claude_telegram_bot-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: claude-telegram-bot
+Version: 0.1.0
+Summary: Telegram bot for interacting with Claude Code CLI
+Project-URL: Homepage, https://github.com/littzhch/claude-telegram-bot
+Project-URL: Repository, https://github.com/littzhch/claude-telegram-bot
+Author-email: littzhch <2371050115@qq.com>
+License: MIT
+Keywords: ai,anthropic,bot,claude,telegram
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: python-telegram-bot>=21.0
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Description-Content-Type: text/markdown
+
+# Claude Telegram Bot
+
+Telegram bot for interacting with Claude Code CLI
+
+## Installation
+
+```bash
+pip install claude-telegram-bot
+```
+
+## Configuration
+
+Configuration priority: CLI > ENV > config file > defaults
+
+### Config File
+
+Create `~/.config/claude-tg-bot.toml`:
+
+```toml
+[telegram]
+bot_token = "your-telegram-bot-token"
+admin_user_id = 123456789
+allowed_user_ids = [123456789]
+
+[claude]
+path = "/home/zhangchi/.local/bin/claude"
+timeout = 120
+
+[data]
+dir = "~/.cache/claude-tg-bot"
+```
+
+### Environment Variables
+
+- `BOT_TOKEN`: Telegram bot token
+- `ADMIN_USER_ID`: Admin user ID
+- `ALLOWED_USER_IDS`: Comma-separated user IDs
+- `CLAUDE_PATH`: Path to Claude CLI
+- `CLAUDE_TIMEOUT`: Command timeout in seconds
+- `DATA_DIR`: Data directory
+
+### CLI Arguments
+
+```bash
+claude-tg-bot --help
+```
+
+## Usage
+
+```bash
+claude-tg-bot --bot-token YOUR_TOKEN
+```

claude_telegram_bot-0.1.0/README.md

@@ -0,0 +1,52 @@
+# Claude Telegram Bot
+
+Telegram bot for interacting with Claude Code CLI
+
+## Installation
+
+```bash
+pip install claude-telegram-bot
+```
+
+## Configuration
+
+Configuration priority: CLI > ENV > config file > defaults
+
+### Config File
+
+Create `~/.config/claude-tg-bot.toml`:
+
+```toml
+[telegram]
+bot_token = "your-telegram-bot-token"
+admin_user_id = 123456789
+allowed_user_ids = [123456789]
+
+[claude]
+path = "/home/zhangchi/.local/bin/claude"
+timeout = 120
+
+[data]
+dir = "~/.cache/claude-tg-bot"
+```
+
+### Environment Variables
+
+- `BOT_TOKEN`: Telegram bot token
+- `ADMIN_USER_ID`: Admin user ID
+- `ALLOWED_USER_IDS`: Comma-separated user IDs
+- `CLAUDE_PATH`: Path to Claude CLI
+- `CLAUDE_TIMEOUT`: Command timeout in seconds
+- `DATA_DIR`: Data directory
+
+### CLI Arguments
+
+```bash
+claude-tg-bot --help
+```
+
+## Usage
+
+```bash
+claude-tg-bot --bot-token YOUR_TOKEN
+```

claude_telegram_bot-0.1.0/config.example.toml

@@ -0,0 +1,16 @@
+# Claude Telegram Bot Configuration
+# Save this to ~/.config/claude-tg-bot.toml
+
+[telegram]
+bot_token = "your-telegram-bot-token"
+admin_user_id = 123456789
+allowed_user_ids = [123456789, 987654321]
+
+[claude]
+path = "/home/zhangchi/.local/bin/claude"
+timeout = 120
+max_history_messages = 40
+
+[data]
+# Directory for storing bot data (default: ~/.cache/claude-tg-bot/)
+# dir = "/custom/path/to/data"

claude_telegram_bot-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "claude-telegram-bot"
+version = "0.1.0"
+description = "Telegram bot for interacting with Claude Code CLI"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "littzhch", email = "2371050115@qq.com"}
+]
+keywords = ["telegram", "bot", "claude", "ai", "anthropic"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "python-telegram-bot>=21.0",
+    "python-dotenv>=1.0",
+    "tomli>=2.0; python_version < '3.11'",
+]
+
+[project.scripts]
+claude-tg-bot = "claude_telegram_bot.bot:main"
+
+[project.urls]
+Homepage = "https://github.com/littzhch/claude-telegram-bot"
+Repository = "https://github.com/littzhch/claude-telegram-bot"
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/claude_telegram_bot"]

claude_telegram_bot-0.1.0/src/claude_telegram_bot/__main__.py

@@ -0,0 +1,3 @@
+from claude_telegram_bot.bot import main
+
+main()

claude_telegram_bot-0.1.0/src/claude_telegram_bot/auth.py

@@ -0,0 +1,49 @@
+import logging
+from functools import wraps
+from telegram import Update
+from telegram.ext import ContextTypes
+
+from claude_telegram_bot import config
+
+logger = logging.getLogger(__name__)
+
+
+def _load_allowed_ids() -> set[int]:
+    """Reload allowed user IDs from config (supports runtime admin changes)."""
+    return set(config.ALLOWED_USER_IDS)
+
+
+def is_allowed(user_id: int) -> bool:
+    allowed = _load_allowed_ids()
+    return user_id in allowed
+
+
+def is_admin(user_id: int) -> bool:
+    return user_id == config.ADMIN_USER_ID
+
+
+def require_auth(func):
+    """Decorator: reject users not in the allowed list."""
+    @wraps(func)
+    async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs):
+        user_id = update.effective_user.id
+        if not is_allowed(user_id):
+            logger.warning("Unauthorized access from user %s", user_id)
+            if update.message:
+                await update.message.reply_text("You are not authorized to use this bot.")
+            return
+        return await func(update, context, *args, **kwargs)
+    return wrapper
+
+
+def require_admin(func):
+    """Decorator: reject non-admin users."""
+    @wraps(func)
+    async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs):
+        user_id = update.effective_user.id
+        if not is_admin(user_id):
+            if update.message:
+                await update.message.reply_text("Admin only.")
+            return
+        return await func(update, context, *args, **kwargs)
+    return wrapper

claude_telegram_bot-0.1.0/src/claude_telegram_bot/bot.py

@@ -0,0 +1,425 @@
+#!/usr/bin/env python3
+"""Telegram Bot for Claude Code CLI."""
+
+import asyncio
+import logging
+import os
+import tempfile
+from pathlib import Path
+from telegram import Update, BotCommand
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    MessageHandler,
+    filters,
+    ContextTypes,
+)
+
+from claude_telegram_bot import config
+from claude_telegram_bot.auth import require_auth, is_admin
+from claude_telegram_bot.claude_runner import run_claude
+from claude_telegram_bot.session_manager import SessionManager, init_db as init_session_db
+from claude_telegram_bot.project_manager import (
+    init_db as init_project_db,
+    add_project,
+    remove_project,
+    list_projects,
+    get_project_path,
+)
+
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+# In-memory session managers per user
+_user_sessions: dict[int, SessionManager] = {}
+
+
+def _get_session(user_id: int) -> SessionManager:
+    if user_id not in _user_sessions:
+        _user_sessions[user_id] = SessionManager(user_id)
+    return _user_sessions[user_id]
+
+
+# ── Commands ──
+
+@require_auth
+async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user = update.effective_user
+    await update.message.reply_text(
+        f"Hello {user.first_name}! I'm your Claude Code bot.\n\n"
+        "Send me any message and I'll run it through Claude Code CLI.\n\n"
+        "Key commands:\n"
+        "/new - Start a new conversation\n"
+        "/sessions - List all sessions\n"
+        "/history - View conversation history\n"
+        "/projects - List configured projects\n"
+        "/add_project <name> <path> - Add a project\n"
+        "/use <project> - Switch to a project\n"
+        "/status - Current status\n"
+        "/help - Show help"
+    )
+
+
+@require_auth
+async def cmd_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    text = (
+        "*Claude Code Telegram Bot*\n\n"
+        "*Conversation*\n"
+        "/new - Start new conversation\n"
+        "/sessions - List all sessions\n"
+        "/switch <id> - Switch session\n"
+        "/history - Show recent history\n\n"
+        "*Projects*\n"
+        "/projects - List projects\n"
+        "/add_project <name> <path> - Add project\n"
+        "/remove_project <name> - Remove project\n"
+        "/use <name> - Switch active project\n\n"
+        "*Status*\n"
+        "/status - Current status\n"
+        "/help - This message\n\n"
+        "*Files*\n"
+        "Send a document to attach it to the conversation.\n"
+        "The file path will be included in the prompt to Claude."
+    )
+    if is_admin(update.effective_user.id):
+        text += (
+            "\n\n*Admin*\n"
+            "/admin add <user_id> - Add user\n"
+            "/admin remove <user_id> - Remove user\n"
+            "/admin list - List allowed users"
+        )
+    await update.message.reply_text(text, parse_mode="Markdown")
+
+
+@require_auth
+async def cmd_new(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    sm = _get_session(update.effective_user.id)
+    sm.new_session()
+    await update.message.reply_text("New conversation started.")
+
+
+@require_auth
+async def cmd_sessions(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    sm = _get_session(update.effective_user.id)
+    sessions = sm.list_sessions()
+    if not sessions:
+        await update.message.reply_text("No sessions yet. Send a message to start one.")
+        return
+
+    lines = []
+    active_id = sm.active_session_id
+    for s in sessions:
+        marker = " *" if s["id"] == active_id else ""
+        lines.append(f"{s['id']}. {s['name']} (updated: {s['updated_at'][:16]}){marker}")
+    await update.message.reply_text(
+        "Sessions (active marked with *):\n" + "\n".join(lines)
+    )
+
+
+@require_auth
+async def cmd_switch(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    if not context.args:
+        await update.message.reply_text("Usage: /switch <session_id>")
+        return
+    try:
+        sid = int(context.args[0])
+    except ValueError:
+        await update.message.reply_text("Invalid session ID.")
+        return
+    sm = _get_session(update.effective_user.id)
+    if sm.switch_session(sid):
+        await update.message.reply_text(f"Switched to session {sid}.")
+    else:
+        await update.message.reply_text(f"Session {sid} not found.")
+
+
+@require_auth
+async def cmd_history(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    sm = _get_session(update.effective_user.id)
+    history = sm.get_history(limit=20)
+    if not history:
+        await update.message.reply_text("No history in current session.")
+        return
+
+    lines = []
+    for msg in history:
+        role = "You" if msg["role"] == "user" else "Claude"
+        content = msg["content"][:200]
+        if len(msg["content"]) > 200:
+            content += "..."
+        lines.append(f"*{role}:* {content}")
+
+    text = "\n\n".join(lines)
+    # Telegram message limit
+    if len(text) > 4000:
+        text = text[:4000] + "\n... (truncated)"
+    await update.message.reply_text(text, parse_mode="Markdown")
+
+
+@require_auth
+async def cmd_projects(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user_id = update.effective_user.id
+    projects = list_projects(user_id)
+    if not projects:
+        await update.message.reply_text(
+            "No projects configured. Use /add_project <name> <path> to add one."
+        )
+        return
+
+    sm = _get_session(user_id)
+    active_cwd = sm.get_active_cwd()
+    lines = []
+    for p in projects:
+        active = " *" if p["path"] == active_cwd else ""
+        lines.append(f"• {p['name']}: {p['path']}{active}")
+    await update.message.reply_text(
+        "Projects (active marked with *):\n" + "\n".join(lines)
+    )
+
+
+@require_auth
+async def cmd_add_project(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    if len(context.args) < 2:
+        await update.message.reply_text("Usage: /add_project <name> <path>")
+        return
+    name = context.args[0]
+    path = " ".join(context.args[1:])
+    user_id = update.effective_user.id
+    ok, msg = add_project(user_id, name, path)
+    await update.message.reply_text(msg)
+
+
+@require_auth
+async def cmd_remove_project(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    if not context.args:
+        await update.message.reply_text("Usage: /remove_project <name>")
+        return
+    name = context.args[0]
+    user_id = update.effective_user.id
+    ok, msg = remove_project(user_id, name)
+    await update.message.reply_text(msg)
+
+
+@require_auth
+async def cmd_use(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    if not context.args:
+        await update.message.reply_text("Usage: /use <project_name>")
+        return
+    name = context.args[0]
+    user_id = update.effective_user.id
+    path = get_project_path(user_id, name)
+    if path is None:
+        await update.message.reply_text(f"Project '{name}' not found. Use /projects to list.")
+        return
+    sm = _get_session(user_id)
+    sm.set_cwd(path)
+    await update.message.reply_text(f"Switched to project '{name}' ({path}).")
+
+
+@require_auth
+async def cmd_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user_id = update.effective_user.id
+    sm = _get_session(user_id)
+    active_cwd = sm.get_active_cwd() or "(default: home)"
+    sessions = sm.list_sessions()
+    active_sid = sm.active_session_id
+    projects = list_projects(user_id)
+
+    text = (
+        f"*Status*\n"
+        f"User ID: {user_id}\n"
+        f"Admin: {'Yes' if is_admin(user_id) else 'No'}\n"
+        f"Active session: {active_sid or 'None'}\n"
+        f"Working directory: {active_cwd}\n"
+        f"Sessions: {len(sessions)}\n"
+        f"Projects: {len(projects)}"
+    )
+    await update.message.reply_text(text, parse_mode="Markdown")
+
+
+# ── Admin ──
+
+@require_auth
+async def cmd_admin(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user_id = update.effective_user.id
+    if not is_admin(user_id):
+        await update.message.reply_text("Admin only.")
+        return
+
+    if not context.args:
+        await update.message.reply_text(
+            "Usage:\n/admin add <user_id>\n/admin remove <user_id>\n/admin list"
+        )
+        return
+
+    action = context.args[0].lower()
+
+    if action == "list":
+        ids = ", ".join(str(uid) for uid in config.ALLOWED_USER_IDS)
+        await update.message.reply_text(f"Allowed user IDs:\n{ids}")
+        return
+
+    if action == "add" and len(context.args) >= 2:
+        try:
+            new_id = int(context.args[1])
+        except ValueError:
+            await update.message.reply_text("Invalid user ID.")
+            return
+        if new_id not in config.ALLOWED_USER_IDS:
+            config.ALLOWED_USER_IDS.append(new_id)
+        await update.message.reply_text(f"Added user {new_id}.")
+        return
+
+    if action == "remove" and len(context.args) >= 2:
+        try:
+            rem_id = int(context.args[1])
+        except ValueError:
+            await update.message.reply_text("Invalid user ID.")
+            return
+        if rem_id in config.ALLOWED_USER_IDS:
+            config.ALLOWED_USER_IDS.remove(rem_id)
+        await update.message.reply_text(f"Removed user {rem_id}.")
+        return
+
+    await update.message.reply_text("Unknown admin command.")
+
+
+# ── File upload ──
+
+@require_auth
+async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle uploaded documents - download and save to session's temp dir."""
+    doc = update.message.document
+    if not doc:
+        return
+
+    user_id = update.effective_user.id
+    sm = _get_session(user_id)
+    cwd = sm.get_active_cwd() or str(Path.home())
+
+    file = await context.bot.get_file(doc.file_id)
+    dest = os.path.join(cwd, doc.file_name or "uploaded_file")
+    await file.download_to_drive(dest)
+
+    sm.add_message("user", f"[Uploaded file: {dest}]")
+    await update.message.reply_text(f"File saved to: {dest}")
+
+
+# ── Message handler ──
+
+@require_auth
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle regular text messages - forward to Claude Code CLI."""
+    text = update.message.text
+    if not text:
+        return
+
+    user_id = update.effective_user.id
+    sm = _get_session(user_id)
+
+    # Ensure we have a session
+    if sm.active_session_id is None:
+        sm.new_session()
+
+    cwd = sm.get_active_cwd() or str(Path.home())
+
+    # Build prompt with history
+    prompt = sm.build_prompt(text)
+
+    # Save user message
+    sm.add_message("user", text)
+
+    # Send "thinking" indicator
+    thinking_msg = await update.message.reply_text("Claude is thinking...")
+
+    try:
+        output = await run_claude(prompt, cwd=cwd, continue_session=False)
+    except Exception as e:
+        output = f"Error: {e}"
+
+    # Save assistant response
+    sm.add_message("assistant", output)
+
+    # Send response (split if too long)
+    await thinking_msg.delete()
+    if len(output) <= 4000:
+        await update.message.reply_text(output)
+    else:
+        # Split into chunks
+        chunks = []
+        while output:
+            chunk = output[:4000]
+            # Try to split at a newline boundary
+            last_nl = chunk.rfind("\n")
+            if last_nl > 2000:
+                chunk = output[:last_nl]
+                output = output[last_nl + 1:]
+            else:
+                output = output[4000:]
+            chunks.append(chunk)
+        for chunk in chunks:
+            await update.message.reply_text(chunk)
+
+
+# ── Main ──
+
+async def post_init(app: Application):
+    """Set bot commands for the Telegram UI."""
+    commands = [
+        BotCommand("start", "Start using the bot"),
+        BotCommand("help", "Show help"),
+        BotCommand("new", "New conversation"),
+        BotCommand("sessions", "List sessions"),
+        BotCommand("switch", "Switch session"),
+        BotCommand("history", "Show history"),
+        BotCommand("projects", "List projects"),
+        BotCommand("add_project", "Add project"),
+        BotCommand("remove_project", "Remove project"),
+        BotCommand("use", "Switch project"),
+        BotCommand("status", "Current status"),
+    ]
+    await app.bot.set_my_commands(commands)
+
+
+def main():
+    if not config.BOT_TOKEN:
+        print("Error: BOT_TOKEN not set. Copy .env.example to .env and configure it.")
+        return
+    if not config.ALLOWED_USER_IDS:
+        print("Warning: ALLOWED_USER_IDS is empty. Only admin can use the bot.")
+
+    # Init databases
+    init_session_db()
+    init_project_db()
+
+    app = Application.builder().token(config.BOT_TOKEN).post_init(post_init).build()
+
+    # Register handlers
+    app.add_handler(CommandHandler("start", cmd_start))
+    app.add_handler(CommandHandler("help", cmd_help))
+    app.add_handler(CommandHandler("new", cmd_new))
+    app.add_handler(CommandHandler("sessions", cmd_sessions))
+    app.add_handler(CommandHandler("switch", cmd_switch))
+    app.add_handler(CommandHandler("history", cmd_history))
+    app.add_handler(CommandHandler("projects", cmd_projects))
+    app.add_handler(CommandHandler("add_project", cmd_add_project))
+    app.add_handler(CommandHandler("remove_project", cmd_remove_project))
+    app.add_handler(CommandHandler("use", cmd_use))
+    app.add_handler(CommandHandler("status", cmd_status))
+    app.add_handler(CommandHandler("admin", cmd_admin))
+
+    # File uploads
+    app.add_handler(MessageHandler(filters.Document.ALL, handle_document))
+
+    # Text messages
+    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+
+    logger.info("Starting bot...")
+    app.run_polling(allowed_updates=Update.ALL_TYPES)
+
+
+if __name__ == "__main__":
+    main()