From 95e4bae6fe55aa10f718ef7ff8afedf3dbce41a0 Mon Sep 17 00:00:00 2001 From: Billy Lui <9884020+billylui@users.noreply.github.com> Date: Wed, 22 Jul 2026 19:30:56 +0800 Subject: [PATCH 01/15] fix: only fall back to plain text on BadRequest, not on transient errors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The send helpers in message_sender.py (send_with_fallback, safe_reply, safe_edit, safe_send) send with parse_mode=MarkdownV2 and, in a broad `except Exception`, resend the message as plain text. On a slow or flaky connection this produces duplicate messages: the formatted send reaches Telegram and is delivered, but the client then raises TimedOut/NetworkError while waiting for the API response. The broad except treats that as a failure and resends as plain text, so the user receives the message twice -- one formatted copy and one plain copy. Narrow the fallback to telegram.error.BadRequest, the only error that proves the formatted message was rejected (and therefore not delivered), so a plain-text retry is the correct recovery. Any other non-RetryAfter error (TimedOut, NetworkError, ...) is ambiguous -- the message may already have been delivered -- so log and do not resend, preferring a rare drop over a duplicate. RetryAfter is still re-raised unchanged for the queue worker's flood-control handling. Add tests covering all four helpers: transient errors send exactly once (no duplicate), BadRequest still retries as plain text, and RetryAfter propagates. 🀖 Generated with Claude Code Co-Authored-By: Claude (cherry picked from commit 3803b905eaabbd8f0bdb81595079a1d52bede80e) --- src/ccbot/handlers/message_sender.py | 53 +++++++++++-- tests/ccbot/test_message_sender.py | 108 +++++++++++++++++++++++++++ 2 files changed, 155 insertions(+), 6 deletions(-) create mode 100644 tests/ccbot/test_message_sender.py diff --git a/src/ccbot/handlers/message_sender.py b/src/ccbot/handlers/message_sender.py index d54cd1396..198000669 100644 --- a/src/ccbot/handlers/message_sender.py +++ b/src/ccbot/handlers/message_sender.py @@ -1,7 +1,10 @@ """Safe message sending helpers with MarkdownV2 fallback. Provides utility functions for sending Telegram messages with automatic -format conversion and fallback to plain text on failure. +format conversion, falling back to plain text only when Telegram rejects the +formatting (BadRequest) — never on an ambiguous transient error such as +TimedOut, which may already have been delivered and would otherwise produce a +duplicate message. Uses telegramify-markdown for MarkdownV2 formatting. @@ -21,7 +24,7 @@ from typing import Any from telegram import Bot, InputMediaPhoto, LinkPreviewOptions, Message -from telegram.error import RetryAfter +from telegram.error import BadRequest, RetryAfter from ..markdown_v2 import convert_markdown from ..transcript_parser import TranscriptParser @@ -72,7 +75,9 @@ async def send_with_fallback( ) except RetryAfter: raise - except Exception: + except BadRequest: + # Telegram rejected the formatted message (e.g. invalid MarkdownV2), so + # it was NOT delivered — retry once as plain text. try: return await bot.send_message( chat_id=chat_id, text=strip_sentinels(text), **kwargs @@ -82,6 +87,16 @@ async def send_with_fallback( except Exception as e: logger.error(f"Failed to send message to {chat_id}: {e}") return None + except Exception as e: + # Any other error (TimedOut, NetworkError, ...) is ambiguous: on a slow + # or flaky connection the formatted send may already have reached + # Telegram before the client raised. Retrying would deliver a duplicate + # (one formatted copy + one plain), so log and give up instead. + logger.warning( + f"Send to {chat_id} raised {type(e).__name__}; not retrying to " + f"avoid a possible duplicate: {e}" + ) + return None async def send_photo( @@ -137,7 +152,8 @@ async def safe_reply(message: Message, text: str, **kwargs: Any) -> Message: ) except RetryAfter: raise - except Exception: + except BadRequest: + # Formatting rejected → not delivered; retry once as plain text. try: return await message.reply_text(strip_sentinels(text), **kwargs) except RetryAfter: @@ -145,6 +161,14 @@ async def safe_reply(message: Message, text: str, **kwargs: Any) -> Message: except Exception as e: logger.error(f"Failed to reply: {e}") raise + except Exception as e: + # Ambiguous error (e.g. TimedOut): the formatted reply may already have + # been delivered. Don't retry (avoids a duplicate); propagate instead. + logger.warning( + f"Reply raised {type(e).__name__}; not retrying to avoid a " + f"possible duplicate: {e}" + ) + raise async def safe_edit(target: Any, text: str, **kwargs: Any) -> None: @@ -158,13 +182,22 @@ async def safe_edit(target: Any, text: str, **kwargs: Any) -> None: ) except RetryAfter: raise - except Exception: + except BadRequest: + # Formatting rejected → the edit was not applied; retry as plain text. try: await target.edit_message_text(strip_sentinels(text), **kwargs) except RetryAfter: raise except Exception as e: logger.error("Failed to edit message: %s", e) + except Exception as e: + # Ambiguous error (e.g. TimedOut): the edit may already have applied. + # Don't retry — a plain-text retry would drop the formatting. + logger.warning( + "Edit raised %s; not retrying to avoid clobbering formatting: %s", + type(e).__name__, + e, + ) async def safe_send( @@ -187,7 +220,8 @@ async def safe_send( ) except RetryAfter: raise - except Exception: + except BadRequest: + # Formatting rejected → not delivered; retry once as plain text. try: await bot.send_message( chat_id=chat_id, text=strip_sentinels(text), **kwargs @@ -196,3 +230,10 @@ async def safe_send( raise except Exception as e: logger.error(f"Failed to send message to {chat_id}: {e}") + except Exception as e: + # Ambiguous error (e.g. TimedOut): the formatted send may already have + # reached Telegram. Retrying would deliver a duplicate, so don't. + logger.warning( + f"Send to {chat_id} raised {type(e).__name__}; not retrying to " + f"avoid a possible duplicate: {e}" + ) diff --git a/tests/ccbot/test_message_sender.py b/tests/ccbot/test_message_sender.py new file mode 100644 index 000000000..80df33749 --- /dev/null +++ b/tests/ccbot/test_message_sender.py @@ -0,0 +1,108 @@ +"""Tests for the send helpers' formatting fallback in message_sender. + +Focus: the fallback to plain text must fire only when Telegram *rejects* the +formatting (BadRequest), never on an ambiguous transient error (e.g. TimedOut), +which may already have delivered the formatted message. Retrying on a transient +error is what produced duplicate messages (one formatted + one plain). +""" + +from unittest.mock import AsyncMock + +import pytest +from telegram.error import BadRequest, NetworkError, RetryAfter, TimedOut + +from ccbot.handlers import message_sender +from ccbot.handlers.message_sender import ( + safe_reply, + safe_send, + send_with_fallback, +) + + +@pytest.fixture(autouse=True) +def _identity_formatter(monkeypatch): + """Isolate these tests from the MarkdownV2 conversion layer.""" + monkeypatch.setattr(message_sender, "_ensure_formatted", lambda text: text) + + +class TestSendWithFallback: + async def test_timeout_does_not_retry_and_avoids_duplicate(self): + # Formatted send raises after (potentially) delivering — must NOT resend. + bot = AsyncMock() + bot.send_message = AsyncMock(side_effect=TimedOut("connection timed out")) + + result = await send_with_fallback(bot, 123, "hello") + + assert result is None + assert bot.send_message.await_count == 1 # no second (duplicate) send + + async def test_network_error_does_not_retry(self): + bot = AsyncMock() + bot.send_message = AsyncMock(side_effect=NetworkError("flaky link")) + + result = await send_with_fallback(bot, 123, "hello") + + assert result is None + assert bot.send_message.await_count == 1 + + async def test_bad_request_falls_back_to_plain_text(self): + # BadRequest = formatting rejected => not delivered => plain retry is safe. + sent = object() + bot = AsyncMock() + bot.send_message = AsyncMock(side_effect=[BadRequest("bad entities"), sent]) + + result = await send_with_fallback(bot, 123, "hello") + + assert result is sent + assert bot.send_message.await_count == 2 + # The plain retry must not carry a parse_mode. + _, retry_kwargs = bot.send_message.await_args_list[1] + assert "parse_mode" not in retry_kwargs + + async def test_retry_after_is_reraised(self): + bot = AsyncMock() + bot.send_message = AsyncMock(side_effect=RetryAfter(5)) + + with pytest.raises(RetryAfter): + await send_with_fallback(bot, 123, "hello") + assert bot.send_message.await_count == 1 + + +class TestSafeSend: + async def test_timeout_does_not_retry(self): + bot = AsyncMock() + bot.send_message = AsyncMock(side_effect=TimedOut("timeout")) + + await safe_send(bot, 123, "hello") + + assert bot.send_message.await_count == 1 + + async def test_bad_request_falls_back_to_plain_text(self): + bot = AsyncMock() + bot.send_message = AsyncMock(side_effect=[BadRequest("bad"), object()]) + + await safe_send(bot, 123, "hello") + + assert bot.send_message.await_count == 2 + _, retry_kwargs = bot.send_message.await_args_list[1] + assert "parse_mode" not in retry_kwargs + + +class TestSafeReply: + async def test_timeout_propagates_without_retry(self): + message = AsyncMock() + message.reply_text = AsyncMock(side_effect=TimedOut("timeout")) + + with pytest.raises(TimedOut): + await safe_reply(message, "hello") + assert message.reply_text.await_count == 1 # no duplicate reply + + async def test_bad_request_falls_back_to_plain_text(self): + sent = object() + message = AsyncMock() + message.reply_text = AsyncMock(side_effect=[BadRequest("bad"), sent]) + + result = await safe_reply(message, "hello") + + assert result is sent + assert message.reply_text.await_count == 2 From 7a0feec42ae2f34a074cf944b349442e2a8f548d Mon Sep 17 00:00:00 2001 From: Paolo Antinori Date: Sat, 11 Jul 2026 16:06:56 +0200 Subject: [PATCH 02/15] feat: configurable transcription model for OpenAI-compatible backends Voice transcription hardcoded the gpt-4o-transcribe model, which blocked reuse of OPENAI_BASE_URL against OpenAI-compatible backends serving different model names (e.g. a self-hosted Whisper server). Add CCBOT_TRANSCRIBE_MODEL (default gpt-4o-transcribe) so the model is configurable, mirroring the existing OPENAI_BASE_URL / OPENAI_API_KEY overrides. Verified end-to-end against a local Speaches instance running Whisper large-v3-turbo. Backwards compatible: unset preserves existing OpenAI behaviour. (cherry picked from commit fba6ad508546940ec556f35cb250f4362e82d3bd) --- src/ccbot/config.py | 6 ++++++ src/ccbot/transcribe.py | 8 +++++--- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/src/ccbot/config.py b/src/ccbot/config.py index 1f3572efc..8757fa3cb 100644 --- a/src/ccbot/config.py +++ b/src/ccbot/config.py @@ -110,6 +110,12 @@ def __init__(self) -> None: self.openai_base_url: str = os.getenv( "OPENAI_BASE_URL", "https://api.openai.com/v1" ) + # Transcription model — override when pointing OPENAI_BASE_URL at an + # OpenAI-compatible backend that serves different model names (e.g. a + # local Whisper server such as Speaches). Default: OpenAI's hosted model. + self.transcribe_model: str = os.getenv( + "CCBOT_TRANSCRIBE_MODEL", "gpt-4o-transcribe" + ) # Scrub sensitive vars from os.environ so child processes never inherit them. # Values are already captured in Config attributes above. diff --git a/src/ccbot/transcribe.py b/src/ccbot/transcribe.py index 8e62a4cd2..8c5710c8d 100644 --- a/src/ccbot/transcribe.py +++ b/src/ccbot/transcribe.py @@ -1,7 +1,9 @@ """Voice-to-text transcription via OpenAI's audio API. -Provides a single async function to transcribe voice messages using -the gpt-4o-transcribe model. Uses httpx directly (no OpenAI SDK needed). +Provides a single async function to transcribe voice messages using a +configurable model (default: gpt-4o-transcribe). Works with any +OpenAI-compatible /audio/transcriptions endpoint. Uses httpx directly +(no OpenAI SDK needed). Key function: transcribe_voice(ogg_data) -> str """ @@ -38,7 +40,7 @@ async def transcribe_voice(ogg_data: bytes) -> str: url, headers={"Authorization": f"Bearer {config.openai_api_key}"}, files={"file": ("voice.ogg", ogg_data, "audio/ogg")}, - data={"model": "gpt-4o-transcribe"}, + data={"model": config.transcribe_model}, ) response.raise_for_status() From b27cbf12a8f1b58a74414c3816b91f7237ad6a76 Mon Sep 17 00:00:00 2001 From: sunchan-park Date: Sat, 7 Mar 2026 20:58:46 +0900 Subject: [PATCH 03/15] fix: adaptive throttle for timer-based status updates to avoid Telegram rate limits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When Claude Code waits on a long-running task (e.g. agent sub-tasks), the status line timer increments every second ("Thinking
 1s", "2s", 
). The status poller detects each tick as a text change and enqueues a Telegram edit_message_text call — roughly 60/min. This quickly exceeds Telegram's rate limit, triggering 429 responses and a flood-control ban that silences the bot for extended periods. Add _should_send_status() in status_polling.py that detects timer suffixes via regex and applies an adaptive send interval based on how long the same status has been active: 0–10 s → every 1 s (real-time, useful for short tasks) 10–60 s → every 5 s 60 s+ → every 30 s Key design decisions: - Poll interval stays at 1 s — interactive UI detection is unaffected - Non-timer status changes always send immediately (no delay) - Timer detection uses a trailing regex matching "5s", "1m 30s", etc. - Intervals are configurable via STATUS_THROTTLE_INTERVALS env var (comma-separated, e.g. "1,5,30"; set "1,1,1" to disable) Co-Authored-By: Claude Opus 4.6 (cherry picked from commit 6e94ed035162d1a08050d3c6ef5d718937942265) --- src/ccbot/config.py | 20 ++ src/ccbot/handlers/status_polling.py | 92 ++++++- tests/ccbot/handlers/test_timer_throttle.py | 258 ++++++++++++++++++++ tests/ccbot/test_config.py | 33 +++ 4 files changed, 401 insertions(+), 2 deletions(-) create mode 100644 tests/ccbot/handlers/test_timer_throttle.py diff --git a/src/ccbot/config.py b/src/ccbot/config.py index 8757fa3cb..d1b3e8a1c 100644 --- a/src/ccbot/config.py +++ b/src/ccbot/config.py @@ -84,6 +84,26 @@ def __init__(self) -> None: self.monitor_poll_interval = float(os.getenv("MONITOR_POLL_INTERVAL", "2.0")) + # Adaptive throttle for timer-based status lines. + # Three comma-separated intervals (seconds) for elapsed-time tiers: + # tier 1 (0–10 s), tier 2 (10–60 s), tier 3 (60 s+) + # Default "1,5,30" means: real-time for first 10 s, then every 5 s, + # then every 30 s. Set to "1,1,1" to disable throttling. + self.status_throttle_intervals: tuple[float, float, float] = (1.0, 5.0, 30.0) + raw = os.getenv("STATUS_THROTTLE_INTERVALS", "") + if raw: + try: + parts = [float(x.strip()) for x in raw.split(",")] + if len(parts) != 3 or any(p < 0 for p in parts): + raise ValueError("need exactly 3 non-negative numbers") + self.status_throttle_intervals = (parts[0], parts[1], parts[2]) + except ValueError as e: + logger.warning( + "Invalid STATUS_THROTTLE_INTERVALS=%r (%s), using defaults", + raw, + e, + ) + # Display user messages in history and real-time notifications # When True, user messages are shown with a 👀 prefix self.show_user_messages = ( diff --git a/src/ccbot/handlers/status_polling.py b/src/ccbot/handlers/status_polling.py index 4fdfbbf1b..38af1bc5f 100644 --- a/src/ccbot/handlers/status_polling.py +++ b/src/ccbot/handlers/status_polling.py @@ -8,21 +8,25 @@ - Periodically probes topic existence via unpin_all_forum_topic_messages (silent no-op when no pins); cleans up deleted topics (kills tmux window + unbinds thread) + - Adaptive throttle for timer-based status lines to avoid Telegram rate limits Key components: - STATUS_POLL_INTERVAL: Polling frequency (1 second) - TOPIC_CHECK_INTERVAL: Topic existence probe frequency (60 seconds) - status_poll_loop: Background polling task - update_status_message: Poll and enqueue status updates + - _should_send_status: Adaptive throttle for timer status updates """ import asyncio import logging +import re import time from telegram import Bot from telegram.error import BadRequest +from ..config import config from ..session import session_manager from ..terminal_parser import ( is_interactive_ui, @@ -40,12 +44,94 @@ logger = logging.getLogger(__name__) -# Status polling interval -STATUS_POLL_INTERVAL = 1.0 # seconds - faster response (rate limiting at send layer) +# Status polling interval — kept at 1s for fast interactive UI detection. +# Timer-based status updates are throttled adaptively by _should_send_status(). +STATUS_POLL_INTERVAL = 1.0 # seconds # Topic existence probe interval TOPIC_CHECK_INTERVAL = 60.0 # seconds +# ── Adaptive throttle for timer status lines ───────────────────────────── +# +# Claude Code shows a running timer in the status line (e.g. "Thinking
 5s", +# "Bash echo hello 1m 30s"). Without throttling, every tick produces a +# Telegram edit_message_text call (~60/min), which quickly hits Telegram's +# rate limit and causes the bot to go silent for extended periods. +# +# Strategy: detect timer suffixes, then increase the update interval the +# longer the same status persists. Default tiers (configurable via +# STATUS_THROTTLE_INTERVALS env var, comma-separated): +# 0–10 s → every 1 s (real-time, meaningful for short tasks) +# 10–60 s → every 5 s +# 60 s+ → every 30 s +# +# Non-timer status changes (e.g. "Reading file" → "Writing file") always +# send immediately. The poll interval itself stays at 1 s so interactive +# UI detection is never delayed. + +# Matches a timer in the status line. Claude Code uses two formats: +# 1. Bare suffix: "Thinking
 5s" or "Bash echo hello 1m 30s" +# 2. Inside parentheses: "Drizzling
 (54s · ↓ 776 tokens)" +# "Coalescing
 (25m 8s · ↓ 5.8k tokens · thought for 6s)" +# Both may include optional trailing text (parenthetical or · metadata). +_TIMER_RE = re.compile( + r"\s+(?:" + r"\((?:\d+m\s*)?\d+s\b[^)]*\)" # (54s · 
) or (1m 30s · 
) + r"|" + r"(?:(?:\d+m\s*)?\d+s|\d+m)" # bare 5s / 1m 30s / 2m + r"(?:\s+\(.*\))?" # optional trailing (Esc to interrupt) + r")\s*$" +) + +# (user_id, thread_id_or_0) → (base_text, first_seen, last_sent) +_timer_throttle: dict[tuple[int, int], tuple[str, float, float]] = {} + + +def _should_send_status( + user_id: int, thread_id: int | None, status_text: str +) -> bool: + """Decide whether a status update should be enqueued. + + For non-timer status lines, always returns True. + For timer status lines, applies adaptive interval based on elapsed time. + """ + key = (user_id, thread_id or 0) + now = time.monotonic() + + m = _TIMER_RE.search(status_text) + if not m: + # Not a timer — always send, clear any tracked state + _timer_throttle.pop(key, None) + return True + + # Extract base text (everything before the timer suffix) + base = status_text[: m.start()].rstrip() + + prev = _timer_throttle.get(key) + if prev is None or prev[0] != base: + # New status or base text changed — reset and send immediately + _timer_throttle[key] = (base, now, now) + return True + + _, first_seen, last_sent = prev + elapsed = now - first_seen + since_sent = now - last_sent + + # Adaptive interval: widen as the timer runs longer + t1, t2, t3 = config.status_throttle_intervals + if elapsed <= 10: + min_interval = t1 # real-time for the first 10 seconds + elif elapsed <= 60: + min_interval = t2 # every few seconds up to 1 minute + else: + min_interval = t3 # reduced frequency for long-running tasks + + if since_sent >= min_interval: + _timer_throttle[key] = (base, first_seen, now) + return True + + return False + async def update_status_message( bot: Bot, @@ -118,6 +204,8 @@ async def update_status_message( ) if status_line: + if not _should_send_status(user_id, thread_id, status_line): + return await enqueue_status_update( bot, user_id, diff --git a/tests/ccbot/handlers/test_timer_throttle.py b/tests/ccbot/handlers/test_timer_throttle.py new file mode 100644 index 000000000..b3d46a626 --- /dev/null +++ b/tests/ccbot/handlers/test_timer_throttle.py @@ -0,0 +1,258 @@ +"""Tests for adaptive timer throttle in status_polling. + +Verifies that _should_send_status() correctly: + - Always passes non-timer status lines + - Sends timer updates every poll for the first 10 s + - Throttles to ~5 s intervals between 10–60 s + - Throttles to ~30 s intervals after 60 s + - Resets when base text changes (different task) + - Resets when status switches from timer to non-timer +""" + +from unittest.mock import patch + +import pytest + +from ccbot.handlers.status_polling import ( + _TIMER_RE, + _should_send_status, + _timer_throttle, +) + + +@pytest.fixture(autouse=True) +def _clear_throttle_state(): + """Ensure throttle state is clean for each test.""" + _timer_throttle.clear() + yield + _timer_throttle.clear() + + +# ── Regex tests ────────────────────────────────────────────────────────── + + +class TestTimerRegex: + """Verify _TIMER_RE matches expected timer suffixes.""" + + @pytest.mark.parametrize( + "text", + [ + "Thinking
 5s", + "Reading file.py 12s", + "Bash echo hello 1m 30s", + "Bash echo hello 1m30s", + "Working 2m", + "Thinking
 5s (Esc to interrupt)", + "Bash ls 1m 30s (Esc to interrupt)", + "Drizzling
 (54s · ↓ 776 tokens)", + "Coalescing
 (25m 8s · ↓ 5.8k tokens · thought for 6s)", + "Thinking
 (3s)", + "Thinking
 (1m 5s · ↓ 12k tokens · thought for 3s)", + ], + ) + def test_timer_detected(self, text: str): + assert _TIMER_RE.search(text) is not None + + @pytest.mark.parametrize( + "text", + [ + "Reading file.py", + "Writing to output", + "Bash echo hello", + "file2s", # no preceding space + "Processing items", + ], + ) + def test_non_timer_not_matched(self, text: str): + assert _TIMER_RE.search(text) is None + + def test_base_text_extraction(self): + text = "Thinking
 45s (Esc to interrupt)" + m = _TIMER_RE.search(text) + assert m is not None + base = text[: m.start()].rstrip() + assert base == "Thinking
" + + def test_base_text_bash(self): + text = "Bash echo hello 1m 30s" + m = _TIMER_RE.search(text) + assert m is not None + base = text[: m.start()].rstrip() + assert base == "Bash echo hello" + + def test_base_text_parenthesized_timer(self): + text = "Coalescing
 (25m 8s · ↓ 5.8k tokens · thought for 6s)" + m = _TIMER_RE.search(text) + assert m is not None + base = text[: m.start()].rstrip() + assert base == "Coalescing
" + + def test_base_text_short_parenthesized(self): + text = "Drizzling
 (54s · ↓ 776 tokens)" + m = _TIMER_RE.search(text) + assert m is not None + base = text[: m.start()].rstrip() + assert base == "Drizzling
" + + +# ── Throttle logic tests ──────────────────────────────────────────────── + + +class TestShouldSendStatus: + """Test adaptive throttle intervals.""" + + def test_non_timer_always_passes(self): + assert _should_send_status(1, 42, "Reading file.py") is True + assert _should_send_status(1, 42, "Reading file.py") is True + assert _should_send_status(1, 42, "Writing output") is True + + def test_first_timer_always_passes(self): + assert _should_send_status(1, 42, "Thinking
 1s") is True + + def test_realtime_within_10s(self): + """Timer updates within first 10s should all pass (1s interval).""" + t0 = 1000.0 + with patch("ccbot.handlers.status_polling.time") as mock_time: + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + + # 2 seconds later — still within 10s window + mock_time.monotonic.return_value = t0 + 2 + assert _should_send_status(1, 42, "Thinking
 3s") is True + + # 1 second later — also passes + mock_time.monotonic.return_value = t0 + 3 + assert _should_send_status(1, 42, "Thinking
 4s") is True + + def test_throttled_after_10s(self): + """After 10s elapsed, interval becomes 5s.""" + t0 = 1000.0 + with patch("ccbot.handlers.status_polling.time") as mock_time: + # First call + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + + # At 11s — first_seen=t0, elapsed=11s, since_sent=11s → passes (>= 5s) + mock_time.monotonic.return_value = t0 + 11 + assert _should_send_status(1, 42, "Thinking
 12s") is True + + # At 13s — since_sent=2s → blocked (< 5s) + mock_time.monotonic.return_value = t0 + 13 + assert _should_send_status(1, 42, "Thinking
 14s") is False + + # At 16s — since_sent=5s → passes (>= 5s) + mock_time.monotonic.return_value = t0 + 16 + assert _should_send_status(1, 42, "Thinking
 17s") is True + + def test_throttled_after_60s(self): + """After 60s elapsed, interval becomes 30s.""" + t0 = 1000.0 + with patch("ccbot.handlers.status_polling.time") as mock_time: + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + + # At 61s — passes (since_sent=61s >= 30s) + mock_time.monotonic.return_value = t0 + 61 + assert _should_send_status(1, 42, "Thinking
 1m 2s") is True + + # At 70s — blocked (since_sent=9s < 30s) + mock_time.monotonic.return_value = t0 + 70 + assert _should_send_status(1, 42, "Thinking
 1m 11s") is False + + # At 91s — passes (since_sent=30s >= 30s) + mock_time.monotonic.return_value = t0 + 91 + assert _should_send_status(1, 42, "Thinking
 1m 32s") is True + + def test_base_text_change_resets(self): + """Changing base text (different task) resets the throttle.""" + t0 = 1000.0 + with patch("ccbot.handlers.status_polling.time") as mock_time: + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + + # Jump to 65s (would be in 30s throttle zone) + mock_time.monotonic.return_value = t0 + 65 + # Same base text — just record it as sent + assert _should_send_status(1, 42, "Thinking
 1m 6s") is True + + # 2s later, different base text — should pass immediately + mock_time.monotonic.return_value = t0 + 67 + assert _should_send_status(1, 42, "Bash echo hello 2s") is True + + def test_non_timer_clears_state(self): + """Switching to non-timer status clears throttle state.""" + t0 = 1000.0 + with patch("ccbot.handlers.status_polling.time") as mock_time: + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + assert (1, 42) in _timer_throttle + + # Non-timer clears state + mock_time.monotonic.return_value = t0 + 5 + assert _should_send_status(1, 42, "Reading file.py") is True + assert (1, 42) not in _timer_throttle + + def test_independent_per_user_thread(self): + """Throttle state is independent per (user_id, thread_id).""" + t0 = 1000.0 + with patch("ccbot.handlers.status_polling.time") as mock_time: + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + assert _should_send_status(1, 99, "Thinking
 1s") is True + assert _should_send_status(2, 42, "Thinking
 1s") is True + + # Jump to 15s zone (5s interval) + mock_time.monotonic.return_value = t0 + 15 + assert _should_send_status(1, 42, "Thinking
 16s") is True + + # 2s later — user 1/thread 42 blocked, but user 2/thread 42 passes + mock_time.monotonic.return_value = t0 + 17 + assert _should_send_status(1, 42, "Thinking
 18s") is False + assert _should_send_status(2, 42, "Thinking
 18s") is True + + def test_none_thread_id(self): + """thread_id=None is treated as 0.""" + assert _should_send_status(1, None, "Thinking
 1s") is True + assert (1, 0) in _timer_throttle + + def test_custom_intervals_from_config(self): + """Intervals are read from config.status_throttle_intervals.""" + t0 = 1000.0 + # Set aggressive throttle: 2s / 10s / 60s + with ( + patch("ccbot.handlers.status_polling.time") as mock_time, + patch( + "ccbot.handlers.status_polling.config.status_throttle_intervals", + (2.0, 10.0, 60.0), + ), + ): + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + + # At t0+1 — within tier 1 (0-10s), but interval=2s → blocked + mock_time.monotonic.return_value = t0 + 1 + assert _should_send_status(1, 42, "Thinking
 2s") is False + + # At t0+2 — since_sent=2s >= 2s → passes + mock_time.monotonic.return_value = t0 + 2 + assert _should_send_status(1, 42, "Thinking
 3s") is True + + def test_disabled_throttle(self): + """Setting all intervals to 1 effectively disables throttling.""" + t0 = 1000.0 + with ( + patch("ccbot.handlers.status_polling.time") as mock_time, + patch( + "ccbot.handlers.status_polling.config.status_throttle_intervals", + (1.0, 1.0, 1.0), + ), + ): + mock_time.monotonic.return_value = t0 + assert _should_send_status(1, 42, "Thinking
 1s") is True + + # At 65s elapsed, interval is still 1s → passes after 1s + mock_time.monotonic.return_value = t0 + 65 + assert _should_send_status(1, 42, "Thinking
 1m 6s") is True + + mock_time.monotonic.return_value = t0 + 66 + assert _should_send_status(1, 42, "Thinking
 1m 7s") is True diff --git a/tests/ccbot/test_config.py b/tests/ccbot/test_config.py index 95cf35f9b..ad5089e1a 100644 --- a/tests/ccbot/test_config.py +++ b/tests/ccbot/test_config.py @@ -117,3 +117,36 @@ def test_openai_api_key_scrubbed_from_env(self, monkeypatch): monkeypatch.setenv("OPENAI_API_KEY", "sk-secret") Config() assert os.environ.get("OPENAI_API_KEY") is None + + +@pytest.mark.usefixtures("_base_env") +class TestConfigStatusThrottle: + def test_default_intervals(self, monkeypatch): + monkeypatch.delenv("STATUS_THROTTLE_INTERVALS", raising=False) + cfg = Config() + assert cfg.status_throttle_intervals == (1.0, 5.0, 30.0) + + def test_custom_intervals(self, monkeypatch): + monkeypatch.setenv("STATUS_THROTTLE_INTERVALS", "2,10,60") + cfg = Config() + assert cfg.status_throttle_intervals == (2.0, 10.0, 60.0) + + def test_disable_throttle(self, monkeypatch): + monkeypatch.setenv("STATUS_THROTTLE_INTERVALS", "1,1,1") + cfg = Config() + assert cfg.status_throttle_intervals == (1.0, 1.0, 1.0) + + def test_invalid_format_uses_defaults(self, monkeypatch): + monkeypatch.setenv("STATUS_THROTTLE_INTERVALS", "bad,input") + cfg = Config() + assert cfg.status_throttle_intervals == (1.0, 5.0, 30.0) + + def test_wrong_count_uses_defaults(self, monkeypatch): + monkeypatch.setenv("STATUS_THROTTLE_INTERVALS", "1,5") + cfg = Config() + assert cfg.status_throttle_intervals == (1.0, 5.0, 30.0) + + def test_negative_value_uses_defaults(self, monkeypatch): + monkeypatch.setenv("STATUS_THROTTLE_INTERVALS", "1,-5,30") + cfg = Config() + assert cfg.status_throttle_intervals == (1.0, 5.0, 30.0) From 64dbb9f94eda9233fc22f28b70b48c5663041393 Mon Sep 17 00:00:00 2001 From: DefaultPerson Date: Wed, 29 Apr 2026 11:53:54 +0300 Subject: [PATCH 04/15] feat: implement /kill and auto-clean dead topic state MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit /kill was registered only as a BotCommand menu hint with no handler, so it fell through to forward_command_handler and was sent into Claude Code as a slash command. Wire up an actual kill_command that kills the tmux window, drops the binding, purges window state, removes the session_map entry, and deletes the Telegram topic. Also fix accumulating orphan state when topics die outside /kill: - session.purge_window / remove_session_map_entry / cleanup_dead_topic - topic_closed_handler now invokes the same purge path - status_polling probe accepts both Topic_id_invalid and Message thread not found (interval lowered 60s -> 5s) - send_with_fallback / safe_send react to those markers immediately — needed because unpinAllForumTopicMessages returns ok=true for private chats with arbitrary thread_ids, so the probe alone cannot detect a deleted topic in DM mode restart.sh now sweeps any \$VENV/bin/ccbot processes outside the target pane to prevent multiple instances racing the same bot token. (cherry picked from commit 4c426c68fffb5d24b3c9656de5f9f7d78909689c) --- scripts/restart.sh | 23 ++++ src/ccbot/bot.py | 50 +++++++++ src/ccbot/handlers/message_sender.py | 29 +++++ src/ccbot/handlers/status_polling.py | 11 +- src/ccbot/session.py | 75 +++++++++++++ tests/ccbot/test_kill_command.py | 158 +++++++++++++++++++++++++++ 6 files changed, 344 insertions(+), 2 deletions(-) create mode 100644 tests/ccbot/test_kill_command.py diff --git a/scripts/restart.sh b/scripts/restart.sh index 7c92a385b..a2ef002eb 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -167,6 +167,29 @@ else echo "No ccbot process running in $TARGET" fi +# Sweep any orphan ccbot processes elsewhere on the host (e.g. another tmux +# server). Multiple instances polling the same bot token compete for updates +# and silently break command routing. +ORPHAN_PIDS=$(pgrep -f '\.venv/bin/ccbot' | grep -vxF "$$" || true) +# Exclude pids inside our target pane's process tree (already handled above) +if [ -n "$ORPHAN_PIDS" ]; then + OWN_TREE=$(pstree -p "$PANE_PID" 2>/dev/null | grep -oE '\([0-9]+\)' | tr -d '()' || true) + for pid in $ORPHAN_PIDS; do + if ! echo "$OWN_TREE" | grep -qx "$pid"; then + echo "Killing orphan ccbot process $pid (outside $TARGET)..." + kill "$pid" 2>/dev/null || true + fi + done + sleep 1 + # Anything still alive — SIGKILL + for pid in $ORPHAN_PIDS; do + if kill -0 "$pid" 2>/dev/null; then + echo "Orphan $pid still alive, SIGKILL..." + kill -9 "$pid" 2>/dev/null || true + fi + done +fi + # Brief pause to let the shell settle sleep 1 diff --git a/src/ccbot/bot.py b/src/ccbot/bot.py index 7fb1b3190..47185a9ce 100644 --- a/src/ccbot/bot.py +++ b/src/ccbot/bot.py @@ -378,6 +378,53 @@ async def unbind_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> ) +async def kill_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: + """Kill the tmux window for this topic and delete the topic itself.""" + user = update.effective_user + if not user or not is_user_allowed(user.id): + return + if not update.message: + return + + thread_id = _get_thread_id(update) + if thread_id is None: + await safe_reply(update.message, "❌ This command only works in a topic.") + return + + wid = session_manager.get_window_for_thread(user.id, thread_id) + if wid: + display = session_manager.get_display_name(wid) + w = await tmux_manager.find_window_by_id(wid) + if w: + await tmux_manager.kill_window(w.window_id) + logger.info( + "/kill: killed window %s (user=%d, thread=%d)", + display, + user.id, + thread_id, + ) + session_manager.unbind_thread(user.id, thread_id) + session_manager.purge_window(wid) + await session_manager.remove_session_map_entry(wid) + await clear_topic_state(user.id, thread_id, context.bot, context.user_data) + + chat = update.effective_chat + if chat is None: + await safe_reply(update.message, "✅ Session killed.") + return + + try: + await context.bot.delete_forum_topic( + chat_id=chat.id, message_thread_id=thread_id + ) + except Exception as e: + logger.warning("delete_forum_topic failed: %s", e) + await safe_reply( + update.message, + "✅ Session killed. Couldn't delete topic — close or delete it manually.", + ) + + async def esc_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None: """Send Escape key to interrupt Claude.""" user = update.effective_user @@ -578,6 +625,8 @@ async def topic_closed_handler( thread_id, ) session_manager.unbind_thread(user.id, thread_id) + session_manager.purge_window(wid) + await session_manager.remove_session_map_entry(wid) # Clean up all memory state for this topic await clear_topic_state(user.id, thread_id, context.bot, context.user_data) else: @@ -2134,6 +2183,7 @@ def create_bot() -> Application: application.add_handler(CommandHandler("history", history_command)) application.add_handler(CommandHandler("screenshot", screenshot_command)) application.add_handler(CommandHandler("esc", esc_command)) + application.add_handler(CommandHandler("kill", kill_command)) application.add_handler(CommandHandler("unbind", unbind_command)) application.add_handler(CommandHandler("usage", usage_command)) application.add_handler(CommandHandler("favorite", favorite_command)) diff --git a/src/ccbot/handlers/message_sender.py b/src/ccbot/handlers/message_sender.py index 198000669..886dd5fab 100644 --- a/src/ccbot/handlers/message_sender.py +++ b/src/ccbot/handlers/message_sender.py @@ -54,6 +54,29 @@ def _ensure_formatted(text: str) -> str: NO_LINK_PREVIEW = LinkPreviewOptions(is_disabled=True) +# Substrings in Telegram errors that mean the topic/thread is gone +_TOPIC_GONE_MARKERS = ("Topic_id_invalid", "Message thread not found") + + +async def _maybe_cleanup_dead_topic( + chat_id: int, kwargs: dict[str, Any], err: BaseException +) -> None: + """If the error indicates a dead forum topic, tear down the binding. + + Called from send fallbacks after both attempts have failed. Lazy-imports + session_manager to avoid a circular import at module load. + """ + msg = str(err) + if not any(m in msg for m in _TOPIC_GONE_MARKERS): + return + thread_id = kwargs.get("message_thread_id") + if thread_id is None: + return + from ..session import session_manager # lazy: avoid circular import + + await session_manager.cleanup_dead_topic(int(chat_id), int(thread_id)) + + async def send_with_fallback( bot: Bot, chat_id: int, @@ -86,6 +109,7 @@ async def send_with_fallback( raise except Exception as e: logger.error(f"Failed to send message to {chat_id}: {e}") + await _maybe_cleanup_dead_topic(chat_id, kwargs, e) return None except Exception as e: # Any other error (TimedOut, NetworkError, ...) is ambiguous: on a slow @@ -230,9 +254,14 @@ async def safe_send( raise except Exception as e: logger.error(f"Failed to send message to {chat_id}: {e}") + await _maybe_cleanup_dead_topic(chat_id, kwargs, e) except Exception as e: # Ambiguous error (e.g. TimedOut): the formatted send may already have # reached Telegram. Retrying would deliver a duplicate, so don't. + # 🔎 죜은 토픜 정늬는 여Ʞ서 부륎지 않는닀 — Topic_id_invalid · + # Message thread not found 는 BadRequest 로 였므로 위 분Ʞ에서 잡힌닀. + # TimedOut·NetworkError 로 토픜을 지우멎 넀튞워크가 흔듀늎 때마닀 + # 멀쩡한 바읞딩읎 ë‚ ì•„ê°„ë‹€. logger.warning( f"Send to {chat_id} raised {type(e).__name__}; not retrying to " f"avoid a possible duplicate: {e}" diff --git a/src/ccbot/handlers/status_polling.py b/src/ccbot/handlers/status_polling.py index 38af1bc5f..e03b1fb4a 100644 --- a/src/ccbot/handlers/status_polling.py +++ b/src/ccbot/handlers/status_polling.py @@ -49,7 +49,10 @@ STATUS_POLL_INTERVAL = 1.0 # seconds # Topic existence probe interval -TOPIC_CHECK_INTERVAL = 60.0 # seconds +TOPIC_CHECK_INTERVAL = 5.0 # seconds + +# Substrings in BadRequest messages that indicate the topic is gone +_TOPIC_GONE_MARKERS = ("Topic_id_invalid", "Message thread not found") # ── Adaptive throttle for timer status lines ───────────────────────────── # @@ -270,12 +273,14 @@ async def status_poll_loop(bot: Bot) -> None: message_thread_id=thread_id, ) except BadRequest as e: - if "Topic_id_invalid" in str(e): + if any(m in str(e) for m in _TOPIC_GONE_MARKERS): # Topic deleted — kill window, unbind, and clean up state w = await tmux_manager.find_window_by_id(wid) if w: await tmux_manager.kill_window(w.window_id) session_manager.unbind_thread(user_id, thread_id) + session_manager.purge_window(wid) + await session_manager.remove_session_map_entry(wid) await clear_topic_state(user_id, thread_id, bot) logger.info( "Topic deleted: killed window_id '%s' and " @@ -304,6 +309,8 @@ async def status_poll_loop(bot: Bot) -> None: w = await resolve_binding_window(user_id, thread_id, wid) if not w: session_manager.unbind_thread(user_id, thread_id) + session_manager.purge_window(wid) + await session_manager.remove_session_map_entry(wid) await clear_topic_state(user_id, thread_id, bot) logger.info( "Cleaned up stale binding: user=%d thread=%d window_id=%s", diff --git a/src/ccbot/session.py b/src/ccbot/session.py index 49f962f54..c7d147da8 100644 --- a/src/ccbot/session.py +++ b/src/ccbot/session.py @@ -953,6 +953,81 @@ async def resolve_session_for_window(self, window_id: str) -> ClaudeSession | No self._save_state() return None + def purge_window(self, window_id: str) -> None: + """Remove all in-memory state for a tmux window after it is killed. + + Drops the window from window_states, window_display_names, and every + user's user_window_offsets, then persists state.json. Thread bindings + are left to the caller (unbind_thread is the inverse op there). + """ + changed = False + if window_id in self.window_states: + del self.window_states[window_id] + changed = True + if window_id in self.window_display_names: + del self.window_display_names[window_id] + changed = True + for uid, offsets in list(self.user_window_offsets.items()): + if window_id in offsets: + del offsets[window_id] + changed = True + if not offsets: + del self.user_window_offsets[uid] + if changed: + self._save_state() + logger.info("Purged window state for %s", window_id) + + async def cleanup_dead_topic(self, chat_id: int, thread_id: int) -> bool: + """Tear down any binding whose chat_id+thread_id matches a dead topic. + + Called from send-failure paths when Telegram returns "Message thread not + found" / "Topic_id_invalid". The 60s topic-existence probe can miss this + in private chats (Telegram returns ok=true for unpinAllForumTopicMessages + on private chats with arbitrary thread_ids). Returns True if any binding + was cleaned up. + """ + cleaned = False + for user_id, t_id, wid in list(self.iter_thread_bindings()): + if t_id != thread_id: + continue + if self.resolve_chat_id(user_id, t_id) != chat_id: + continue + self.unbind_thread(user_id, t_id) + self.purge_window(wid) + await self.remove_session_map_entry(wid) + cleaned = True + logger.info( + "Auto-cleaned dead topic via send error: " + "user=%d thread=%d window_id=%s", + user_id, + t_id, + wid, + ) + return cleaned + + async def remove_session_map_entry(self, window_id: str) -> None: + """Delete the session_map.json entry for a window. + + session_map.json is owned by the Claude Code SessionStart hook, but + the hook does not emit a "session ended" event, so killed windows + leave orphan entries. We rewrite the file atomically. + """ + if not config.session_map_file.exists(): + return + try: + async with aiofiles.open(config.session_map_file, "r") as f: + content = await f.read() + session_map = json.loads(content) + except (json.JSONDecodeError, OSError): + return + + key = f"{config.tmux_session_name}:{window_id}" + if key not in session_map: + return + del session_map[key] + atomic_write_json(config.session_map_file, session_map) + logger.info("Removed session_map entry: %s", key) + # --- User window offset management --- def update_user_window_offset( diff --git a/tests/ccbot/test_kill_command.py b/tests/ccbot/test_kill_command.py new file mode 100644 index 000000000..ed74df8b6 --- /dev/null +++ b/tests/ccbot/test_kill_command.py @@ -0,0 +1,158 @@ +"""Tests for kill_command — kill tmux window and delete forum topic.""" + +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest + + +def _make_update(user_id: int = 1, thread_id: int = 42) -> MagicMock: + update = MagicMock() + update.effective_user = MagicMock() + update.effective_user.id = user_id + update.message = MagicMock() + update.message.message_thread_id = thread_id + update.effective_chat = MagicMock() + update.effective_chat.id = 100 + update.effective_chat.type = "supergroup" + return update + + +def _make_context() -> MagicMock: + context = MagicMock() + context.bot = AsyncMock() + context.user_data = {} + return context + + +class TestKillCommand: + @pytest.mark.asyncio + async def test_kill_in_bound_topic_kills_window_and_deletes_topic(self): + update = _make_update() + context = _make_context() + + with ( + patch("ccbot.bot.is_user_allowed", return_value=True), + patch("ccbot.bot._get_thread_id", return_value=42), + patch("ccbot.bot.session_manager") as mock_sm, + patch("ccbot.bot.tmux_manager") as mock_tmux, + patch("ccbot.bot.clear_topic_state", new_callable=AsyncMock), + patch("ccbot.bot.safe_reply", new_callable=AsyncMock) as mock_reply, + ): + mock_sm.get_window_for_thread.return_value = "@5" + mock_sm.get_display_name.return_value = "project" + mock_sm.remove_session_map_entry = AsyncMock() + mock_window = MagicMock() + mock_window.window_id = "@5" + mock_tmux.find_window_by_id = AsyncMock(return_value=mock_window) + mock_tmux.kill_window = AsyncMock() + + from ccbot.bot import kill_command + + await kill_command(update, context) + + mock_tmux.kill_window.assert_called_once_with("@5") + mock_sm.unbind_thread.assert_called_once_with(1, 42) + mock_sm.purge_window.assert_called_once_with("@5") + mock_sm.remove_session_map_entry.assert_awaited_once_with("@5") + context.bot.delete_forum_topic.assert_called_once_with( + chat_id=100, message_thread_id=42 + ) + mock_reply.assert_not_called() + + @pytest.mark.asyncio + async def test_kill_in_unbound_topic_still_deletes_topic(self): + update = _make_update() + context = _make_context() + + with ( + patch("ccbot.bot.is_user_allowed", return_value=True), + patch("ccbot.bot._get_thread_id", return_value=42), + patch("ccbot.bot.session_manager") as mock_sm, + patch("ccbot.bot.tmux_manager") as mock_tmux, + patch("ccbot.bot.clear_topic_state", new_callable=AsyncMock), + patch("ccbot.bot.safe_reply", new_callable=AsyncMock), + ): + mock_sm.get_window_for_thread.return_value = None + mock_tmux.kill_window = AsyncMock() + + from ccbot.bot import kill_command + + await kill_command(update, context) + + mock_tmux.kill_window.assert_not_called() + mock_sm.unbind_thread.assert_not_called() + context.bot.delete_forum_topic.assert_called_once_with( + chat_id=100, message_thread_id=42 + ) + + @pytest.mark.asyncio + async def test_kill_outside_topic_replies_with_error(self): + update = _make_update() + context = _make_context() + + with ( + patch("ccbot.bot.is_user_allowed", return_value=True), + patch("ccbot.bot._get_thread_id", return_value=None), + patch("ccbot.bot.session_manager") as mock_sm, + patch("ccbot.bot.tmux_manager") as mock_tmux, + patch("ccbot.bot.safe_reply", new_callable=AsyncMock) as mock_reply, + ): + mock_tmux.kill_window = AsyncMock() + + from ccbot.bot import kill_command + + await kill_command(update, context) + + mock_reply.assert_called_once() + mock_tmux.kill_window.assert_not_called() + mock_sm.unbind_thread.assert_not_called() + context.bot.delete_forum_topic.assert_not_called() + + @pytest.mark.asyncio + async def test_kill_falls_back_to_reply_when_delete_fails(self): + update = _make_update() + context = _make_context() + context.bot.delete_forum_topic = AsyncMock(side_effect=RuntimeError("nope")) + + with ( + patch("ccbot.bot.is_user_allowed", return_value=True), + patch("ccbot.bot._get_thread_id", return_value=42), + patch("ccbot.bot.session_manager") as mock_sm, + patch("ccbot.bot.tmux_manager") as mock_tmux, + patch("ccbot.bot.clear_topic_state", new_callable=AsyncMock), + patch("ccbot.bot.safe_reply", new_callable=AsyncMock) as mock_reply, + ): + mock_sm.get_window_for_thread.return_value = "@5" + mock_sm.get_display_name.return_value = "project" + mock_sm.remove_session_map_entry = AsyncMock() + mock_window = MagicMock() + mock_window.window_id = "@5" + mock_tmux.find_window_by_id = AsyncMock(return_value=mock_window) + mock_tmux.kill_window = AsyncMock() + + from ccbot.bot import kill_command + + await kill_command(update, context) + + mock_tmux.kill_window.assert_called_once_with("@5") + mock_reply.assert_called_once() + + @pytest.mark.asyncio + async def test_kill_rejects_unauthorized_user(self): + update = _make_update() + context = _make_context() + + with ( + patch("ccbot.bot.is_user_allowed", return_value=False), + patch("ccbot.bot.session_manager") as mock_sm, + patch("ccbot.bot.tmux_manager") as mock_tmux, + ): + mock_tmux.kill_window = AsyncMock() + + from ccbot.bot import kill_command + + await kill_command(update, context) + + mock_tmux.kill_window.assert_not_called() + mock_sm.unbind_thread.assert_not_called() + context.bot.delete_forum_topic.assert_not_called() From 321f0dd6ba355c1832b1d85d6bdafa39195194e8 Mon Sep 17 00:00:00 2001 From: TejNote Date: Wed, 16 Sep 2026 12:16:50 +0900 Subject: [PATCH 05/15] =?UTF-8?q?fix(status):=20=EC=83=81=ED=83=9C?= =?UTF-8?q?=EC=A4=84=20=EC=95=84=EB=9E=98=20tip=20=EB=B8=94=EB=A1=9D?= =?UTF-8?q?=EC=9D=B4=20=EB=81=BC=EB=A9=B4=20=EC=83=81=ED=83=9C=EB=A5=BC=20?= =?UTF-8?q?=EB=86=93=EC=B9=98=EB=8D=98=20=EA=B2=83=20(upstream=20#97)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Claude Code 가 상태쀄곌 chrome 구분선 사읎에 tip 랔록을 렌더하멎, 구분선 바로 위 한 쀄만 볎던 êž°ì¡Ž 로직읎 "상태 없음" 윌로 판정했닀. 위로 더 훑되, 바로 윗쀄읎 아닌 위치에서는 `
` 륌 가진 쀄만 상태로 읞정한닀 — 음반 출력의 `·` 불늿곌 완료 표시(`✻ Sautéed for 7s`)륌 걞러낎Ʞ 위핎서닀. fork 고유의 백귞띌욎드 ì…ž 필터(_BACKGROUND_SHELL_RE)는 귞대로 볎졎했닀. 독슀튞링도 바뀐 동작에 맞춰 고쳀닀 — 죌석읎 거짓읎 되멎 닀음 사람읎 속는닀. Tested: pytest tests/ccbot/test_terminal_parser.py 54항 통곌 (upstream 테슀튞 2걎 추가) Co-Authored-By: Claude Opus 5 (1M context) --- src/ccbot/terminal_parser.py | 26 +++++++++++++++++--------- tests/ccbot/test_terminal_parser.py | 17 +++++++++++++++++ 2 files changed, 34 insertions(+), 9 deletions(-) diff --git a/src/ccbot/terminal_parser.py b/src/ccbot/terminal_parser.py index e8d542b5f..2bbe78c51 100644 --- a/src/ccbot/terminal_parser.py +++ b/src/ccbot/terminal_parser.py @@ -267,10 +267,13 @@ def parse_codex_status_line(pane_text: str) -> str | None: def parse_status_line(pane_text: str) -> str | None: """Extract the Claude Code status line from terminal output. - The status line (spinner + working text) appears immediately above - the chrome separator (a full line of ``─`` characters). We locate - the separator first, then check the line just above it — this avoids - false positives from ``·`` bullets in Claude's regular output. + The status line (spinner + working text) appears above the chrome + separator (a full line of ``─`` characters). We locate the separator + first, then scan upward. The line *directly* above it counts as a status + line on the spinner alone; further up, Claude Code may have rendered a tip + block in between, so a spinner line only counts when it also carries the + ``
`` of a live status — that keeps ``·`` bullets in regular output and the + finished marker (``✻ Sautéed for 7s``) from being mistaken for status. Returns the text after the spinner, or None if no status line found. @@ -297,12 +300,18 @@ def parse_status_line(pane_text: str) -> str | None: if chrome_idx is None: return None # No chrome visible — can't determine status - # Check lines just above the separator (skip blanks, up to 4 lines) - for i in range(chrome_idx - 1, max(chrome_idx - 5, -1), -1): + # Scan upward for the spinner line. Claude Code can render a tip block + # between the status line and the chrome, so keep looking past non-spinner + # lines — but once we're past the line directly above the separator, only a + # live status line counts. The ellipsis is what marks one, and it keeps + # prose bullets and the finished marker ("✻ Sautéed for 7s") out. + # (upstream six-ddc/ccbot#97) + adjacent = True + for i in range(chrome_idx - 1, max(chrome_idx - 9, -1), -1): line = lines[i].strip() if not line: continue - if line[0] in STATUS_SPINNERS: + if line[0] in STATUS_SPINNERS and (adjacent or "
" in line): rest = line[1:].strip() if ( _BACKGROUND_SHELL_RE.search(rest) @@ -310,8 +319,7 @@ def parse_status_line(pane_text: str) -> str | None: ): return None return rest - # First non-empty line above separator isn't a spinner → no status - return None + adjacent = False return None diff --git a/tests/ccbot/test_terminal_parser.py b/tests/ccbot/test_terminal_parser.py index 54e824ba4..665964e89 100644 --- a/tests/ccbot/test_terminal_parser.py +++ b/tests/ccbot/test_terminal_parser.py @@ -59,6 +59,23 @@ def test_false_positive_bullet(self, chrome: str): pane = f"· bullet point one\n· bullet point two\nsome result\n{chrome}" assert parse_status_line(pane) is None + def test_tip_block_between_status_and_chrome(self, chrome: str): + """Claude Code renders a tip block under the status line (upstream #97).""" + pane = ( + "some output\n" + "✳ Gitifying
 (2m 1s · ↓ 6.5k tokens)\n" + " ⎿ Tip: Use /btw to ask a quick side question without interrupting\n" + " current work\n" + "\n" + f"{chrome}" + ) + assert parse_status_line(pane) == "Gitifying
 (2m 1s · ↓ 6.5k tokens)" + + def test_finished_marker_is_not_status(self, chrome: str): + """The completed marker carries no ellipsis and must not count.""" + pane = f"some output\n✻ Sautéed for 7s\nsome result\n{chrome}" + assert parse_status_line(pane) is None + def test_uses_fixture(self, sample_pane_status_line: str): assert parse_status_line(sample_pane_status_line) == "Reading file src/main.py" From 5a96168ee7f2aeba4f5889d83ebfcf4cc186eb5a Mon Sep 17 00:00:00 2001 From: TejNote Date: Wed, 16 Sep 2026 12:19:35 +0900 Subject: [PATCH 06/15] =?UTF-8?q?fix(typing):=20=ED=83=80=EC=9D=B4?= =?UTF-8?q?=ED=95=91=20=ED=91=9C=EC=8B=9C=EB=A5=BC=20=EC=83=81=ED=83=9C?= =?UTF-8?q?=ED=8F=B4=EB=A7=81=EC=9D=B4=20=EB=AA=B0=EC=95=84=EC=84=9C=20?= =?UTF-8?q?=EC=BC=A0=EB=8B=A4=20(upstream=20#98)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 예전에는 상태 메시지륌 볎낎거나 펞집할 때마닀 "esc to interrupt" 가 듀얎 있윌멎 chat action 을 한 번 쏘는 방식읎었닀. 텔레귞랚은 chat action 을 ì•œ 5쎈 ë’€ 지우므로, 상태 텍슀튞가 안 바뀌는 ꞎ 구간에서는 타읎핑 표시가 꺌진 채로 낚았닀. 읎제 상태쀄 파싱 결곌(= 에읎전튞가 턮 쀑읞지 아는 유음한 지점)가 set_typing 을 혞출하고, keepalive 태슀크가 4쎈마닀 갱신한닀. 상태 메시지 삭제·토픜 정늬·뎇 종료 ì„ž 겜로에서 태슀크륌 췚소한닀. fork 고유 지점 반영: - status_polling 의 codex 분Ʞ(parse_codex_status_line)도 같은 게읎튞륌 탄닀 - upstream 은 chat action 에 thread 륌 안 싀었지만 여Ʞ서는 _send_kwargs 로 message_thread_id 륌 넘ꞎ닀 — 토픜 몚드가 Ʞ볞읎띌 안 넘Ʞ멎 엉뚱한 곳에 뜬닀 Tested: pytest 402항 통곌 · ruff 위반 main 103 → 100 (슝가 없음) Co-Authored-By: Claude Opus 5 (1M context) --- src/ccbot/handlers/message_queue.py | 68 ++++++++++++++++++++-------- src/ccbot/handlers/status_polling.py | 7 ++- 2 files changed, 56 insertions(+), 19 deletions(-) diff --git a/src/ccbot/handlers/message_queue.py b/src/ccbot/handlers/message_queue.py index de3eb0f0b..11bcd698a 100644 --- a/src/ccbot/handlers/message_queue.py +++ b/src/ccbot/handlers/message_queue.py @@ -95,6 +95,12 @@ class DirectMessage: # Status message tracking: (user_id, thread_id_or_0) -> (message_id, window_id, last_text) _status_msg_info: dict[tuple[int, int], tuple[int, str, str]] = {} +# Typing keepalive tasks: (user_id, thread_id_or_0) -> repeating chat-action task +_typing_tasks: dict[tuple[int, int], asyncio.Task[None]] = {} + +# Telegram clears a chat action after ~5s, so refresh just under that. +TYPING_REFRESH_INTERVAL = 4.0 + # Flood control: user_id -> monotonic time when ban expires _flood_until: dict[int, float] = {} @@ -502,6 +508,7 @@ async def _convert_status_to_content( Returns the message_id if converted successfully, None otherwise. """ skey = (user_id, thread_id_or_0) + set_typing(bot, user_id, thread_id_or_0 or None, False) info = _status_msg_info.pop(skey, None) if not info: return None @@ -549,6 +556,42 @@ async def _convert_status_to_content( return None +def set_typing(bot: Bot, user_id: int, thread_id: int | None, active: bool) -> None: + """Light or clear the typing indicator for a session. + + Status polling is the single caller that knows whether Claude is working, + so it drives this. Telegram expires a chat action after ~5s, so an active + session needs it re-sent on a timer rather than once per state change. + """ + skey = (user_id, thread_id or 0) + if active: + if skey not in _typing_tasks: + chat_id = session_manager.resolve_chat_id(user_id, thread_id) + _typing_tasks[skey] = asyncio.create_task( + _typing_keepalive(bot, chat_id, thread_id) + ) + return + task = _typing_tasks.pop(skey, None) + if task: + task.cancel() + + +async def _typing_keepalive(bot: Bot, chat_id: int, thread_id: int | None) -> None: + """Re-send the typing chat action until cancelled.""" + while True: + try: + await bot.send_chat_action( + chat_id=chat_id, + action=ChatAction.TYPING, + **_send_kwargs(thread_id), # type: ignore[arg-type] + ) + except asyncio.CancelledError: + raise + except Exception as e: + logger.debug(f"typing keepalive failed for chat {chat_id}: {e}") + await asyncio.sleep(TYPING_REFRESH_INTERVAL) + + async def _process_status_update_task( bot: Bot, user_id: int, task: MessageTask ) -> None: @@ -578,16 +621,7 @@ async def _process_status_update_task( return else: # Same window, text changed - edit in place - # Send typing indicator when Claude is working - if "esc to interrupt" in status_text.lower(): - try: - await bot.send_chat_action( - chat_id=chat_id, action=ChatAction.TYPING - ) - except RetryAfter: - raise - except Exception: - pass + # (타읎핑 표시는 set_typing 의 keepalive 가 닎당한닀 — upstream #98) try: await bot.edit_message_text( chat_id=chat_id, @@ -638,14 +672,6 @@ async def _do_send_status_message( await bot.delete_message(chat_id=chat_id, message_id=old[0]) except Exception: pass - # Send typing indicator when Claude is working - if "esc to interrupt" in text.lower(): - try: - await bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING) - except RetryAfter: - raise - except Exception: - pass sent = await send_with_fallback( bot, chat_id, @@ -801,6 +827,9 @@ def clear_status_msg_info(user_id: int, thread_id: int | None = None) -> None: """Clear status message tracking for a user (and optionally a specific thread).""" skey = (user_id, thread_id or 0) _status_msg_info.pop(skey, None) + typing = _typing_tasks.pop(skey, None) + if typing: + typing.cancel() def clear_tool_msg_ids_for_topic(user_id: int, thread_id: int | None = None) -> None: @@ -819,6 +848,9 @@ def clear_tool_msg_ids_for_topic(user_id: int, thread_id: int | None = None) -> async def shutdown_workers() -> None: """Stop all queue workers (called during bot shutdown).""" + for _, typing in list(_typing_tasks.items()): + typing.cancel() + _typing_tasks.clear() for _, worker in list(_queue_workers.items()): worker.cancel() try: diff --git a/src/ccbot/handlers/status_polling.py b/src/ccbot/handlers/status_polling.py index e03b1fb4a..a91651901 100644 --- a/src/ccbot/handlers/status_polling.py +++ b/src/ccbot/handlers/status_polling.py @@ -40,7 +40,7 @@ handle_interactive_ui, ) from .cleanup import clear_topic_state -from .message_queue import enqueue_status_update, get_message_queue +from .message_queue import enqueue_status_update, get_message_queue, set_typing logger = logging.getLogger(__name__) @@ -206,6 +206,11 @@ async def update_status_message( parse_codex_status_line(pane_text) if is_codex else parse_status_line(pane_text) ) + # A parsed status line means the agent is mid-turn — this is the one place + # that knows. Telegram clears a chat action after ~5s, so an active session + # needs it re-sent on a timer, not once per state change. (upstream #98) + set_typing(bot, user_id, thread_id, bool(status_line)) + if status_line: if not _should_send_status(user_id, thread_id, status_line): return From 047b588927461fefc6b55d8b33a17e57bf4081db Mon Sep 17 00:00:00 2001 From: TejNote Date: Wed, 16 Sep 2026 12:20:45 +0900 Subject: [PATCH 07/15] =?UTF-8?q?fix(commands):=20=EB=AA=85=EB=A0=B9=20?= =?UTF-8?q?=EB=A9=94=EB=89=B4=EB=A5=BC=20=EC=8A=A4=EC=BD=94=ED=94=84=20?= =?UTF-8?q?=EC=A0=84=EC=B2=B4=EC=97=90=20=EB=93=B1=EB=A1=9D=ED=95=9C?= =?UTF-8?q?=EB=8B=A4=20(upstream=20#99)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 텔레귞랚 큎띌읎얞튞는 **ê·ž 채팅에 맞는 슀윔프**의 명령 목록을 읜는닀. 좁은 슀윔프가 Ʞ볞 슀윔프륌 읎Ʞ므로, 옛 섀정(BotFather·구버전)읎 낚ꞎ all_private_chats 목록 하나가 진짜 메뉎륌 가늰닀. 포럌 토픜에서 "/" 버튌읎 비얎 볎읎던 원읞읎닀. - 지욞 때는 ꎀ늬자 슀윔프까지 넓게(_COMMAND_CLEAR_SCOPES) - ì“ž 때는 싀제로 쓰는 슀윔프에 전부(_COMMAND_WRITE_SCOPES) - 슀윔프별 싀팚는 warning 만 ë‚šêž°ê³  나뚞지 슀윔프는 계속 시도한닀 fork 고유 지점: upstream 은 post_init 2곳만 고쳀지만 읎 fork 는 슀킬 슐겚찟Ʞ 토Ꞁ에서 런타임 재등록을 한 번 더 한닀(bot.py:1860). 거Ʞ까지 같은 헬퍌륌 태워알 토Ꞁ 뒀에 메뉎가 닀시 좁은 슀윔프만 갖는 상태로 돌아가지 않는닀. CC_COMMANDS 에 upstream 읎 추가한 5개(agents·context·recap·status·tasks)륌 넣되 섀명은 읎 fork 의 한국얎 슀타음로 맞췄닀. Tested: pytest 402항 통곌 · ruff 신규 위반 0 (bot.py I001 은 main 에도 있는 êž°ì¡Ž 것) Co-Authored-By: Claude Opus 5 (1M context) --- src/ccbot/bot.py | 44 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 3 deletions(-) diff --git a/src/ccbot/bot.py b/src/ccbot/bot.py index 47185a9ce..a7efa71db 100644 --- a/src/ccbot/bot.py +++ b/src/ccbot/bot.py @@ -41,6 +41,9 @@ from telegram import ( Bot, BotCommand, + BotCommandScopeAllChatAdministrators, + BotCommandScopeAllGroupChats, + BotCommandScopeAllPrivateChats, InlineKeyboardButton, InlineKeyboardMarkup, InputMediaDocument, @@ -155,12 +158,17 @@ # Claude Code commands shown in bot menu (forwarded via tmux) CC_COMMANDS: dict[str, str] = { + "agents": "↗ 서람에읎전튞 ꎀ늬", "clear": "↗ 대화 Ʞ록 쎈Ʞ화", "compact": "↗ 컚텍슀튞 압축", + "context": "↗ 컚텍슀튞 사용량 확읞", "cost": "↗ 토큰/비용 확읞", "help": "↗ Claude Code 도움말", "memory": "↗ CLAUDE.md 펞집", "model": "↗ AI 몚덞 전환", + "recap": "↗ 읎 ì„žì…˜ 요앜", + "status": "↗ ì„žì…˜ 상태 확읞", + "tasks": "↗ 백귞띌욎드 작업·서람에읎전튞 목록", } _skill_registry: SkillRegistry | None = None @@ -227,6 +235,36 @@ } +# 큎띌읎얞튞는 **ê·ž 채팅에 맞는 슀윔프**륌 읜는닀. 좁은 슀윔프가 Ʞ볞 슀윔프륌 읎Ʞ므로, +# 옛 섀정(BotFather·구버전)읎 낚ꞎ all_private_chats 목록 하나가 진짜 메뉎륌 가늰닀. +# 귞래서 지욞 때는 ꎀ늬자 슀윔프까지 넓게 지우고, ì“ž 때는 싀제로 쓰는 슀윔프에 ë‹€ ì“Žë‹€. +# (upstream six-ddc/ccbot#99 — 포럌 토픜에서 "/" 버튌읎 비얎 볎읎던 묞제) +_COMMAND_WRITE_SCOPES = ( + None, + BotCommandScopeAllPrivateChats, + BotCommandScopeAllGroupChats, +) +_COMMAND_CLEAR_SCOPES = _COMMAND_WRITE_SCOPES + (BotCommandScopeAllChatAdministrators,) + + +async def _clear_bot_commands(bot: Bot) -> None: + """Drop the command menu from every scope we might have written before.""" + for scope in _COMMAND_CLEAR_SCOPES: + try: + await bot.delete_my_commands(scope=scope() if scope else None) + except Exception as e: + logger.warning("delete_my_commands(%s) failed: %s", scope, e) + + +async def _publish_bot_commands(bot: Bot, commands: list[BotCommand]) -> None: + """Register the command menu on every scope the bot is used from.""" + for scope in _COMMAND_WRITE_SCOPES: + try: + await bot.set_my_commands(commands, scope=scope() if scope else None) + except Exception as e: + logger.warning("set_my_commands(%s) failed: %s", scope, e) + + def _build_bot_commands() -> list[BotCommand]: """Build the full list of bot commands: built-in + CC + skills.""" commands = [ @@ -1819,7 +1857,7 @@ async def callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) - ) # Re-register commands with new order new_commands = _build_bot_commands() - await context.bot.set_my_commands(new_commands) + await _publish_bot_commands(context.bot, new_commands) else: await query.answer("Unknown skill") @@ -2091,7 +2129,7 @@ async def handle_new_message(msg: NewMessage, bot: Bot) -> None: async def post_init(application: Application) -> None: global session_monitor, _status_poll_task, _skill_registry - await application.bot.delete_my_commands() + await _clear_bot_commands(application.bot) # Initialize skill registry and scan plugins _skill_registry = SkillRegistry( @@ -2101,7 +2139,7 @@ async def post_init(application: Application) -> None: _skill_registry.scan() bot_commands = _build_bot_commands() - await application.bot.set_my_commands(bot_commands) + await _publish_bot_commands(application.bot, bot_commands) # Delete status messages left over from the previous run (orphaned on restart) orphaned = session_manager.pop_all_status_msg_ids() From f50b828711bc21b29c2723a72b83eeca54902376 Mon Sep 17 00:00:00 2001 From: Stelatix Date: Sun, 9 Aug 2026 16:04:00 +0200 Subject: [PATCH 08/15] fix: require "**" prefix for Telegram expandable blockquotes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit _render_expandable_quote() built raw MarkdownV2 blockquotes as ">line1\n>line2||" — missing the "**" that Telegram's grammar requires to open an *expandable* quote. Without it, the trailing "||" is an unmatched spoiler entity: Telegram rejects the whole sendMessage call with "Can't parse entities", and the caller's fallback resends the message as unformatted plain text with no collapsing at all. This path is hit by most non-trivial notifications: thinking blocks, Bash/Grep/Glob/Task/WebFetch/WebSearch tool_result output, multi-line tool errors, and Edit diffs all go through _format_expandable_quote(). So instead of a collapsed "N lines, tap to expand" block, the full raw content (including repeated tracebacks in log-heavy output) was landing directly in the chat. Fix: promote the first ">" of the rendered block to "**>", matching telegramify_markdown's own render_quote() implementation. Existing tests asserted the old (broken) shape; updated them and added coverage for multi-line and truncated quotes. Co-Authored-By: Claude Sonnet 5 (cherry picked from commit 5d3bc34e3b7dccb673961764c844d8cc4cbe1a9e) --- src/ccbot/markdown_v2.py | 13 ++++++++++--- tests/ccbot/test_markdown_v2.py | 25 +++++++++++++++++++++++-- 2 files changed, 33 insertions(+), 5 deletions(-) diff --git a/src/ccbot/markdown_v2.py b/src/ccbot/markdown_v2.py index d01bbdf86..ff3c7e7a8 100644 --- a/src/ccbot/markdown_v2.py +++ b/src/ccbot/markdown_v2.py @@ -124,6 +124,12 @@ def _escape_mdv2(text: str) -> str: def _render_expandable_quote(m: re.Match[str]) -> str: """Render an expandable blockquote block in raw MarkdownV2. + Telegram's expandable-quote grammar requires the first quoted line to + start with "**>" (not plain ">"); otherwise the trailing "||" is an + unmatched spoiler entity and the whole sendMessage call is rejected + with "Can't parse entities", silently degrading the message to + unformatted plain text via the caller's fallback path. + Truncates the rendered output to _EXPQUOTE_MAX_RENDERED chars to ensure the final message fits within Telegram's 4096 limit. """ @@ -148,9 +154,10 @@ def _render_expandable_quote(m: re.Match[str]) -> str: break built.append(f">{line}") total_len += line_cost - if truncated: - return "\n".join(built) + suffix - return "\n".join(built) + "||" + body = "\n".join(built) + (suffix if truncated else "||") + # Mark the block as expandable by promoting the first ">" to "**>". + idx = body.index(">") + return body[:idx] + "**" + body[idx:] def _markdownify(text: str) -> str: diff --git a/tests/ccbot/test_markdown_v2.py b/tests/ccbot/test_markdown_v2.py index 3628b185f..ceb77a3a5 100644 --- a/tests/ccbot/test_markdown_v2.py +++ b/tests/ccbot/test_markdown_v2.py @@ -46,13 +46,34 @@ def test_expandable_quote_sentinels(self) -> None: result = convert_markdown(text) assert EXP_START not in result assert EXP_END not in result - assert ">quoted content||" in result + # Telegram requires "**>" (not plain ">") to open an *expandable* + # blockquote — otherwise the trailing "||" is an unmatched spoiler + # entity and Telegram rejects the whole message. + assert "**>quoted content||" in result def test_mixed_text_and_expandable_quote(self) -> None: text = f"before {EXP_START}inside quote{EXP_END} after" result = convert_markdown(text) assert EXP_START not in result assert EXP_END not in result - assert ">inside quote||" in result + assert "**>inside quote||" in result assert "before" in result assert "after" in result + + def test_multiline_expandable_quote_only_first_line_marked(self) -> None: + text = f"{EXP_START}line one\nline two\nline three{EXP_END}" + result = convert_markdown(text) + assert "**>line one" in result + assert "\n>line two" in result + assert "\n>line three||" in result + # Only the first line carries the "**" expandability marker. + assert result.count("**>") == 1 + + def test_expandable_quote_truncation_keeps_expandable_marker(self) -> None: + text = f"{EXP_START}{'x' * 10000}{EXP_END}" + result = convert_markdown(text) + assert "**>" in result + assert result.index("**>") < 10 + assert "\\(truncated\\)||" in result + # Rendered quote block must still fit Telegram's message limit. + assert len(result) < 4096 From da02e0d149060fd4e2d382ecbad7420902952093 Mon Sep 17 00:00:00 2001 From: Stelatix Date: Sun, 9 Aug 2026 16:04:16 +0200 Subject: [PATCH 09/15] feat: delete secondary messages once the next one arrives MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Live notifications for a topic used to accumulate indefinitely: every thinking block, tool_use/tool_result, local-command echo, and even the bot's own echo of the user's outgoing message stayed in the chat forever, alongside the actual assistant answer. For tool-call-heavy sessions (e.g. a monitoring loop polling journalctl) this buried the real answer under a growing wall of technical messages. Add per-topic tracking of the last "secondary" message (_secondary_msg_info, keyed like the existing _status_msg_info / _tool_msg_ids). Secondary means everything except the final assistant text answer: thinking, tool_use, tool_result, local_command, and the role=user echo of a forwarded message. Whenever a new message arrives for a topic, the previously tracked secondary message is deleted; the new message is tracked in its place if it's itself secondary, or left untouched if it's the final answer. Whatever happens to be last simply never gets deleted, so a completed turn naturally leaves only the answer behind — no separate "is this the final message" detection needed. Final text answers are never deleted or tracked, per prior discussion (multiple text blocks in one turn should all persist). tool_use -> tool_result keeps its existing edit-in-place behavior (same message_id, so the secondary tracking stays valid across the edit) rather than being folded into delete+resend. _can_merge_tasks() now also refuses to merge a secondary task with a non-secondary one, since the merged task can only carry one is_secondary value. clear_topic_state() clears the new tracking on topic close. Co-Authored-By: Claude Sonnet 5 (cherry picked from commit e0089f1abb3f23f52ea1e223afaad045ed7b96c0) --- src/ccbot/bot.py | 7 + src/ccbot/handlers/cleanup.py | 10 +- src/ccbot/handlers/message_queue.py | 51 ++++++- tests/ccbot/handlers/test_message_queue.py | 158 +++++++++++++++++++++ 4 files changed, 221 insertions(+), 5 deletions(-) create mode 100644 tests/ccbot/handlers/test_message_queue.py diff --git a/src/ccbot/bot.py b/src/ccbot/bot.py index a7efa71db..28297f3af 100644 --- a/src/ccbot/bot.py +++ b/src/ccbot/bot.py @@ -2100,6 +2100,12 @@ async def handle_new_message(msg: NewMessage, bot: Bot) -> None: # Enqueue content message task # Note: tool_result editing is handled inside _process_content_task # to ensure sequential processing with tool_use message sending + # + # Everything except the final assistant text answer (thinking, + # tool_use, tool_result, local_command, user-message echo) is + # "secondary" — it gets deleted once the next message for this + # topic arrives, so only the actual answer is left behind. + is_secondary = not (msg.role == "assistant" and msg.content_type == "text") await enqueue_content_message( bot=bot, user_id=user_id, @@ -2110,6 +2116,7 @@ async def handle_new_message(msg: NewMessage, bot: Bot) -> None: text=msg.text, thread_id=thread_id, image_data=msg.image_data, + is_secondary=is_secondary, ) # Update user's read offset to current file position diff --git a/src/ccbot/handlers/cleanup.py b/src/ccbot/handlers/cleanup.py index cd7e75805..4751841be 100644 --- a/src/ccbot/handlers/cleanup.py +++ b/src/ccbot/handlers/cleanup.py @@ -12,7 +12,11 @@ from telegram import Bot from .interactive_ui import clear_interactive_msg -from .message_queue import clear_status_msg_info, clear_tool_msg_ids_for_topic +from .message_queue import ( + clear_secondary_msg_info, + clear_status_msg_info, + clear_tool_msg_ids_for_topic, +) async def clear_topic_state( @@ -30,6 +34,7 @@ async def clear_topic_state( Cleans up: - _status_msg_info (status message tracking) - _tool_msg_ids (tool_use → message_id mapping) + - _secondary_msg_info (last deletable secondary message per topic) - _interactive_msgs and _interactive_mode (interactive UI state) - user_data pending state (_pending_thread_id, _pending_thread_text) """ @@ -39,6 +44,9 @@ async def clear_topic_state( # Clear tool message ID tracking clear_tool_msg_ids_for_topic(user_id, thread_id) + # Clear secondary-message tracking + clear_secondary_msg_info(user_id, thread_id) + # Clear interactive UI state (also deletes message from chat) await clear_interactive_msg(user_id, bot, thread_id) diff --git a/src/ccbot/handlers/message_queue.py b/src/ccbot/handlers/message_queue.py index 11bcd698a..7f2bc29a2 100644 --- a/src/ccbot/handlers/message_queue.py +++ b/src/ccbot/handlers/message_queue.py @@ -15,6 +15,10 @@ - Message queue worker: Background task processing user's queue - Content task processing with tool_use/tool_result handling - Status message tracking and conversion (keyed by (user_id, thread_id)) + - Secondary message tracking: the last non-final (thinking/tool_use/ + tool_result/local_command/user-echo) message per topic is deleted as + soon as the next message arrives, so only the final assistant answer + is left behind once a turn completes. """ import asyncio @@ -64,6 +68,10 @@ class MessageTask: content_type: str = "text" thread_id: int | None = None # Telegram topic thread_id for targeted send image_data: list[tuple[str, bytes]] | None = None # From tool_result images + # True for everything except the final assistant text answer (thinking, + # tool_use, tool_result, local_command, user-message echo). Secondary + # messages are deleted as soon as the next message for the topic arrives. + is_secondary: bool = False @dataclass @@ -101,6 +109,10 @@ class DirectMessage: # Telegram clears a chat action after ~5s, so refresh just under that. TYPING_REFRESH_INTERVAL = 4.0 +# Last secondary (non-final) content message per topic, deleted once the +# next message arrives: (user_id, thread_id_or_0) -> (message_id, window_id) +_secondary_msg_info: dict[tuple[int, int], tuple[int, str]] = {} + # Flood control: user_id -> monotonic time when ban expires _flood_until: dict[int, float] = {} @@ -159,7 +171,9 @@ def _can_merge_tasks(base: MessageTask, candidate: MessageTask) -> bool: return False if candidate.content_type in ("tool_use", "tool_result"): return False - return True + # Never fold a secondary (deletable) message together with the final + # answer — the merged task would inherit only one is_secondary value. + return base.is_secondary == candidate.is_secondary async def _merge_content_tasks( @@ -224,6 +238,7 @@ async def _merge_content_tasks( tool_use_id=first.tool_use_id, content_type=first.content_type, thread_id=first.thread_id, + is_secondary=first.is_secondary, ), merge_count, ) @@ -455,7 +470,20 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No logger.debug(f"Failed to edit tool msg {edit_msg_id}, sending new") # Fall through to send as new message - # 2. Send content messages, converting status message to first content part + # 2. A new message is arriving for this topic — delete whatever secondary + # (non-final) message was left over from the previous one. Applies + # whether this new task is itself secondary or the final answer: either + # way the old one is now superseded and safe to remove. + skey = (user_id, tid) + old_secondary = _secondary_msg_info.pop(skey, None) + if old_secondary: + old_msg_id, _old_wid = old_secondary + try: + await bot.delete_message(chat_id=chat_id, message_id=old_msg_id) + except Exception: + pass + + # 3. Send content messages, converting status message to first content part first_part = True last_msg_id: int | None = None for part in task.parts: @@ -485,15 +513,22 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No if sent: last_msg_id = sent.message_id - # 3. Record tool_use message ID for later editing + # 4. Record tool_use message ID for later editing if last_msg_id and task.tool_use_id and task.content_type == "tool_use": _tool_msg_ids[(task.tool_use_id, user_id, tid)] = last_msg_id - # 4. Send images if present (from tool_result with base64 image blocks) + # 5. Track this message as the topic's current secondary message, so it + # gets deleted once the next message (of any kind) arrives. + if last_msg_id and task.is_secondary: + _secondary_msg_info[skey] = (last_msg_id, wid) + + # 6. Send images if present (from tool_result with base64 image blocks) await _send_task_images(bot, chat_id, task) # Status display is delegated to status_polling (1s interval) so the answer # always remains the last visible message until polling detects working state. + # 🔎 upstream 은 여Ʞ서 _check_and_send_status 륌 읞띌읞 혞출한닀(#94 도 ê·ž 자늬륌 + # 걎드늰닀). 읎 fork 는 ê·ž 혞출을 의도적윌로 뺐윌므로 되삎늬지 않는닀. async def _convert_status_to_content( @@ -738,6 +773,7 @@ async def enqueue_content_message( text: str | None = None, thread_id: int | None = None, image_data: list[tuple[str, bytes]] | None = None, + is_secondary: bool = False, ) -> None: """Enqueue a content message task.""" logger.debug( @@ -757,6 +793,7 @@ async def enqueue_content_message( content_type=content_type, thread_id=thread_id, image_data=image_data, + is_secondary=is_secondary, ) queue.put_nowait(task) @@ -832,6 +869,12 @@ def clear_status_msg_info(user_id: int, thread_id: int | None = None) -> None: typing.cancel() +def clear_secondary_msg_info(user_id: int, thread_id: int | None = None) -> None: + """Clear secondary-message tracking for a user (and optionally a specific thread).""" + skey = (user_id, thread_id or 0) + _secondary_msg_info.pop(skey, None) + + def clear_tool_msg_ids_for_topic(user_id: int, thread_id: int | None = None) -> None: """Clear tool message ID tracking for a specific topic. diff --git a/tests/ccbot/handlers/test_message_queue.py b/tests/ccbot/handlers/test_message_queue.py new file mode 100644 index 000000000..9e1f3f79f --- /dev/null +++ b/tests/ccbot/handlers/test_message_queue.py @@ -0,0 +1,158 @@ +"""Tests for message_queue — secondary-message rolling delete-on-next behavior. + +Covers: _can_merge_tasks refusing to fold secondary and final-answer tasks +together, _process_content_task deleting the previous secondary message +when the next one arrives, the tool_use/tool_result edit-in-place path +being left untouched by that deletion, and clear_secondary_msg_info. +""" + +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest + +from ccbot.handlers.message_queue import ( + MessageTask, + _can_merge_tasks, + _process_content_task, + _secondary_msg_info, + _tool_msg_ids, + clear_secondary_msg_info, +) + +USER_ID = 1 +THREAD_ID = 42 +CHAT_ID = 555 + + +@pytest.fixture +def mock_bot(): + bot = AsyncMock() + sent = MagicMock() + sent.message_id = 100 + bot.send_message.return_value = sent + return bot + + +@pytest.fixture(autouse=True) +def _clear_queue_state(): + _secondary_msg_info.clear() + _tool_msg_ids.clear() + yield + _secondary_msg_info.clear() + _tool_msg_ids.clear() + + +def _task( + content_type: str, + is_secondary: bool, + parts: list[str] | None = None, + tool_use_id: str | None = None, +) -> MessageTask: + return MessageTask( + task_type="content", + window_id="@1", + parts=parts or ["hello"], + content_type=content_type, + thread_id=THREAD_ID, + is_secondary=is_secondary, + tool_use_id=tool_use_id, + ) + + +class TestCanMergeSecondary: + def test_secondary_and_final_do_not_merge(self) -> None: + base = _task("thinking", is_secondary=True) + candidate = _task("text", is_secondary=False) + assert _can_merge_tasks(base, candidate) is False + + def test_same_secondary_merges(self) -> None: + base = _task("thinking", is_secondary=True) + candidate = _task("thinking", is_secondary=True) + assert _can_merge_tasks(base, candidate) is True + + +@pytest.mark.asyncio +class TestSecondaryMessageRollingDelete: + async def test_secondary_message_is_tracked(self, mock_bot: AsyncMock) -> None: + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) + + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + mock_bot.delete_message.assert_not_called() + + async def test_next_secondary_deletes_previous(self, mock_bot: AsyncMock) -> None: + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) + + second_sent = MagicMock() + second_sent.message_id = 101 + mock_bot.send_message.return_value = second_sent + await _process_content_task(mock_bot, USER_ID, _task("tool_result", True)) + + mock_bot.delete_message.assert_called_once_with(chat_id=CHAT_ID, message_id=100) + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (101, "@1") + + async def test_final_answer_deletes_previous_but_is_not_tracked( + self, mock_bot: AsyncMock + ) -> None: + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) + + final_sent = MagicMock() + final_sent.message_id = 102 + mock_bot.send_message.return_value = final_sent + await _process_content_task( + mock_bot, USER_ID, _task("text", False, parts=["Fixed it"]) + ) + + mock_bot.delete_message.assert_called_once_with(chat_id=CHAT_ID, message_id=100) + assert (USER_ID, THREAD_ID) not in _secondary_msg_info + + async def test_tool_result_edit_in_place_does_not_delete( + self, mock_bot: AsyncMock + ) -> None: + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + await _process_content_task( + mock_bot, USER_ID, _task("tool_use", True, tool_use_id="tu1") + ) + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + + await _process_content_task( + mock_bot, USER_ID, _task("tool_result", True, tool_use_id="tu1") + ) + + mock_bot.delete_message.assert_not_called() + mock_bot.edit_message_text.assert_called_once() + # Same message_id throughout — edited in place, tracking stays valid. + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + + +class TestClearSecondaryMsgInfo: + def test_clears_tracked_entry(self) -> None: + _secondary_msg_info[(USER_ID, THREAD_ID)] = (100, "@1") + clear_secondary_msg_info(USER_ID, THREAD_ID) + assert (USER_ID, THREAD_ID) not in _secondary_msg_info From 284cd4ad99fed58452ae534ee4461ce4512da596 Mon Sep 17 00:00:00 2001 From: Stelatix Date: Sun, 9 Aug 2026 16:32:02 +0200 Subject: [PATCH 10/15] fix: don't orphan secondary messages on flood-control delete failures MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit _process_content_task's rolling delete-on-next logic popped the tracked secondary message out of _secondary_msg_info before attempting bot.delete_message, then swallowed all errors with a bare `except Exception: pass` — which also caught RetryAfter. Under a burst of several messages to the same topic within a couple seconds (thinking + tool_use/tool_result + task-notification text + interactive-UI polling, all hitting the same chat), Telegram's flood control could reject the delete; the exception was silently dropped and the message was already forgotten, so nothing ever cleaned it up. Keep the entry in _secondary_msg_info until the delete actually succeeds (or is given up on for a non-retryable reason), and re-raise RetryAfter so the existing _process_content_with_retry wrapper retries the whole task — a retry now finds the same tracked message and can still delete it, instead of leaking it forever. Co-Authored-By: Claude Sonnet 5 (cherry picked from commit b381ccca386150a469d7b639c68762d1dbbc34cb) --- src/ccbot/handlers/message_queue.py | 16 +++++-- tests/ccbot/handlers/test_message_queue.py | 50 ++++++++++++++++++++++ 2 files changed, 63 insertions(+), 3 deletions(-) diff --git a/src/ccbot/handlers/message_queue.py b/src/ccbot/handlers/message_queue.py index 7f2bc29a2..830ec3134 100644 --- a/src/ccbot/handlers/message_queue.py +++ b/src/ccbot/handlers/message_queue.py @@ -474,14 +474,24 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No # (non-final) message was left over from the previous one. Applies # whether this new task is itself secondary or the final answer: either # way the old one is now superseded and safe to remove. + # + # Left in place (not popped) until the delete actually succeeds or is + # given up on: on RetryAfter we re-raise so _process_content_with_retry + # retries this whole task, and the retry must still find the same + # tracked message to delete — popping eagerly here would silently + # orphan it (never deleted, never retried) under flood control. skey = (user_id, tid) - old_secondary = _secondary_msg_info.pop(skey, None) + old_secondary = _secondary_msg_info.get(skey) if old_secondary: old_msg_id, _old_wid = old_secondary try: await bot.delete_message(chat_id=chat_id, message_id=old_msg_id) - except Exception: - pass + _secondary_msg_info.pop(skey, None) + except RetryAfter: + raise + except Exception as e: + logger.debug("Failed to delete secondary message %d: %s", old_msg_id, e) + _secondary_msg_info.pop(skey, None) # 3. Send content messages, converting status message to first content part first_part = True diff --git a/tests/ccbot/handlers/test_message_queue.py b/tests/ccbot/handlers/test_message_queue.py index 9e1f3f79f..04e478cf8 100644 --- a/tests/ccbot/handlers/test_message_queue.py +++ b/tests/ccbot/handlers/test_message_queue.py @@ -9,6 +9,7 @@ from unittest.mock import AsyncMock, MagicMock, patch import pytest +from telegram.error import RetryAfter from ccbot.handlers.message_queue import ( MessageTask, @@ -150,6 +151,55 @@ async def test_tool_result_edit_in_place_does_not_delete( # Same message_id throughout — edited in place, tracking stays valid. assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + async def test_retry_after_on_delete_keeps_tracking_for_retry( + self, mock_bot: AsyncMock + ) -> None: + """A flood-controlled delete must not orphan the tracked message. + + Regression test: popping _secondary_msg_info before the delete call + succeeded meant a RetryAfter (bare `except Exception: pass`) silently + dropped the delete and forgot the message — it was never cleaned up + by a later retry. The entry must survive so a retried call can still + find and delete it. + """ + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + + mock_bot.delete_message.side_effect = RetryAfter(5) + with pytest.raises(RetryAfter): + await _process_content_task(mock_bot, USER_ID, _task("tool_result", True)) + + # Still tracked (not silently dropped) so a retry can delete it. + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + + async def test_non_retryable_delete_failure_still_clears_tracking( + self, mock_bot: AsyncMock + ) -> None: + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) + + mock_bot.delete_message.side_effect = Exception("message to delete not found") + second_sent = MagicMock() + second_sent.message_id = 101 + mock_bot.send_message.return_value = second_sent + await _process_content_task(mock_bot, USER_ID, _task("tool_result", True)) + + # Gives up cleanly rather than retrying forever, and still tracks the new message. + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (101, "@1") + class TestClearSecondaryMsgInfo: def test_clears_tracked_entry(self) -> None: From 415b31ec407acaa380fc85c638445fcfe5d2d86e Mon Sep 17 00:00:00 2001 From: Stelatix Date: Sun, 9 Aug 2026 16:53:57 +0200 Subject: [PATCH 11/15] fix: track every message from a merged secondary task, not just the last MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit _merge_content_tasks folds several secondary entries that arrive close together (task-notification bursts observed at 3-4 messages within tens of milliseconds) into one MessageTask with multiple `parts`. Each part is sent as its own Telegram message, but _secondary_msg_info only recorded the id of the last one — the earlier N-1 messages were sent, immediately forgotten, and never deleted by the rolling cleanup, no matter how many further messages arrived afterward. Same issue applies to a single (unmerged) secondary task whose content gets paginated into multiple messages by split_message. Change _secondary_msg_info's value from a single message_id to a list of ids, collected from every part actually sent (including one converted from a status message). Deletion now walks the whole list; on RetryAfter mid-list, already-deleted ids are dropped and the remainder is written back before re-raising, so a retry of the task resumes exactly where it left off instead of re-deleting or losing track of entries. Co-Authored-By: Claude Sonnet 5 (cherry picked from commit 00b58ed47adb19d58cc5f4c87cd7d71b19bcbec8) --- src/ccbot/handlers/message_queue.py | 57 ++++++++----- tests/ccbot/handlers/test_message_queue.py | 97 +++++++++++++++++++--- 2 files changed, 122 insertions(+), 32 deletions(-) diff --git a/src/ccbot/handlers/message_queue.py b/src/ccbot/handlers/message_queue.py index 830ec3134..700ff184c 100644 --- a/src/ccbot/handlers/message_queue.py +++ b/src/ccbot/handlers/message_queue.py @@ -109,9 +109,12 @@ class DirectMessage: # Telegram clears a chat action after ~5s, so refresh just under that. TYPING_REFRESH_INTERVAL = 4.0 -# Last secondary (non-final) content message per topic, deleted once the -# next message arrives: (user_id, thread_id_or_0) -> (message_id, window_id) -_secondary_msg_info: dict[tuple[int, int], tuple[int, str]] = {} +# Last secondary (non-final) content message(s) per topic, deleted once the +# next message arrives: (user_id, thread_id_or_0) -> (message_ids, window_id). +# A list because merged tasks (several secondary entries queued together get +# folded into one MessageTask by _merge_content_tasks) or a paginated +# local_command can produce more than one Telegram message per task. +_secondary_msg_info: dict[tuple[int, int], tuple[list[int], str]] = {} # Flood control: user_id -> monotonic time when ban expires _flood_until: dict[int, float] = {} @@ -475,27 +478,33 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No # whether this new task is itself secondary or the final answer: either # way the old one is now superseded and safe to remove. # - # Left in place (not popped) until the delete actually succeeds or is - # given up on: on RetryAfter we re-raise so _process_content_with_retry - # retries this whole task, and the retry must still find the same - # tracked message to delete — popping eagerly here would silently - # orphan it (never deleted, never retried) under flood control. + # Remaining (not-yet-deleted) ids are written back before re-raising + # RetryAfter, so _process_content_with_retry's retry of this whole + # task resumes deleting exactly where it left off instead of losing + # track of ids already popped — same reasoning as for a single id, + # just extended to a list (see the flood-control regression test). skey = (user_id, tid) old_secondary = _secondary_msg_info.get(skey) if old_secondary: - old_msg_id, _old_wid = old_secondary - try: - await bot.delete_message(chat_id=chat_id, message_id=old_msg_id) - _secondary_msg_info.pop(skey, None) - except RetryAfter: - raise - except Exception as e: - logger.debug("Failed to delete secondary message %d: %s", old_msg_id, e) - _secondary_msg_info.pop(skey, None) + old_msg_ids, old_wid = old_secondary + remaining_ids = list(old_msg_ids) + while remaining_ids: + old_msg_id = remaining_ids[0] + try: + await bot.delete_message(chat_id=chat_id, message_id=old_msg_id) + remaining_ids.pop(0) + except RetryAfter: + _secondary_msg_info[skey] = (remaining_ids, old_wid) + raise + except Exception as e: + logger.debug("Failed to delete secondary message %d: %s", old_msg_id, e) + remaining_ids.pop(0) + _secondary_msg_info.pop(skey, None) # 3. Send content messages, converting status message to first content part first_part = True last_msg_id: int | None = None + sent_msg_ids: list[int] = [] for part in task.parts: sent = None @@ -511,6 +520,7 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No ) if converted_msg_id is not None: last_msg_id = converted_msg_id + sent_msg_ids.append(converted_msg_id) continue sent = await send_with_fallback( @@ -522,15 +532,20 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No if sent: last_msg_id = sent.message_id + sent_msg_ids.append(sent.message_id) # 4. Record tool_use message ID for later editing if last_msg_id and task.tool_use_id and task.content_type == "tool_use": _tool_msg_ids[(task.tool_use_id, user_id, tid)] = last_msg_id - # 5. Track this message as the topic's current secondary message, so it - # gets deleted once the next message (of any kind) arrives. - if last_msg_id and task.is_secondary: - _secondary_msg_info[skey] = (last_msg_id, wid) + # 5. Track every message sent for this task as the topic's current + # secondary message(s), so all of them get deleted once the next + # message (of any kind) arrives — not just the last one. A merged + # task (several secondary entries queued together, folded into one + # MessageTask by _merge_content_tasks) or a paginated local_command + # can produce more than one Telegram message here. + if sent_msg_ids and task.is_secondary: + _secondary_msg_info[skey] = (sent_msg_ids, wid) # 6. Send images if present (from tool_result with base64 image blocks) await _send_task_images(bot, chat_id, task) diff --git a/tests/ccbot/handlers/test_message_queue.py b/tests/ccbot/handlers/test_message_queue.py index 04e478cf8..81a4a1b58 100644 --- a/tests/ccbot/handlers/test_message_queue.py +++ b/tests/ccbot/handlers/test_message_queue.py @@ -1,9 +1,11 @@ """Tests for message_queue — secondary-message rolling delete-on-next behavior. Covers: _can_merge_tasks refusing to fold secondary and final-answer tasks -together, _process_content_task deleting the previous secondary message -when the next one arrives, the tool_use/tool_result edit-in-place path -being left untouched by that deletion, and clear_secondary_msg_info. +together, _process_content_task deleting the previous secondary message(s) +when the next one arrives (including multi-part tasks from merging or +pagination), the tool_use/tool_result edit-in-place path being left +untouched by that deletion, flood-control resilience, and +clear_secondary_msg_info. """ from unittest.mock import AsyncMock, MagicMock, patch @@ -84,7 +86,7 @@ async def test_secondary_message_is_tracked(self, mock_bot: AsyncMock) -> None: await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) - assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([100], "@1") mock_bot.delete_message.assert_not_called() async def test_next_secondary_deletes_previous(self, mock_bot: AsyncMock) -> None: @@ -103,7 +105,7 @@ async def test_next_secondary_deletes_previous(self, mock_bot: AsyncMock) -> Non await _process_content_task(mock_bot, USER_ID, _task("tool_result", True)) mock_bot.delete_message.assert_called_once_with(chat_id=CHAT_ID, message_id=100) - assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (101, "@1") + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([101], "@1") async def test_final_answer_deletes_previous_but_is_not_tracked( self, mock_bot: AsyncMock @@ -140,7 +142,7 @@ async def test_tool_result_edit_in_place_does_not_delete( await _process_content_task( mock_bot, USER_ID, _task("tool_use", True, tool_use_id="tu1") ) - assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([100], "@1") await _process_content_task( mock_bot, USER_ID, _task("tool_result", True, tool_use_id="tu1") @@ -149,7 +151,58 @@ async def test_tool_result_edit_in_place_does_not_delete( mock_bot.delete_message.assert_not_called() mock_bot.edit_message_text.assert_called_once() # Same message_id throughout — edited in place, tracking stays valid. - assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([100], "@1") + + async def test_multi_part_secondary_task_tracks_every_message( + self, mock_bot: AsyncMock + ) -> None: + """Regression test for merged secondary tasks losing all but the last id. + + _merge_content_tasks folds several secondary entries that arrived + close together (e.g. task-notification bursts) into one MessageTask + with several `parts`. Each part is sent as its own Telegram message; + all of them — not just the last — must be tracked so the next + message deletes every one of them instead of leaking all but one. + """ + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + sent_ids = iter([201, 202, 203]) + + def _send(*_a, **_kw): + m = MagicMock() + m.message_id = next(sent_ids) + return m + + mock_bot.send_message.side_effect = _send + + merged = _task("text", True, parts=["notif 1", "notif 2", "notif 3"]) + await _process_content_task(mock_bot, USER_ID, merged) + + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([201, 202, 203], "@1") + assert mock_bot.send_message.call_count == 3 + + # Next message must delete all three, not just the last. + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + next_sent = MagicMock() + next_sent.message_id = 204 + mock_bot.send_message.side_effect = None + mock_bot.send_message.return_value = next_sent + await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) + + deleted_ids = {c.kwargs["message_id"] for c in mock_bot.delete_message.call_args_list} + assert deleted_ids == {201, 202, 203} + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([204], "@1") async def test_retry_after_on_delete_keeps_tracking_for_retry( self, mock_bot: AsyncMock @@ -170,14 +223,36 @@ async def test_retry_after_on_delete_keeps_tracking_for_retry( mock_tmux.find_window_by_id = AsyncMock(return_value=None) await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) - assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([100], "@1") mock_bot.delete_message.side_effect = RetryAfter(5) with pytest.raises(RetryAfter): await _process_content_task(mock_bot, USER_ID, _task("tool_result", True)) # Still tracked (not silently dropped) so a retry can delete it. - assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (100, "@1") + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([100], "@1") + + async def test_retry_after_partway_through_a_multi_id_delete_keeps_remainder( + self, mock_bot: AsyncMock + ) -> None: + """RetryAfter partway through deleting several tracked ids must not + re-attempt (or lose track of) the ones already handled.""" + _secondary_msg_info[(USER_ID, THREAD_ID)] = ([301, 302, 303], "@1") + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + + # First delete succeeds, second is flood-controlled. + mock_bot.delete_message.side_effect = [None, RetryAfter(5)] + with pytest.raises(RetryAfter): + await _process_content_task(mock_bot, USER_ID, _task("thinking", True)) + + assert mock_bot.delete_message.call_count == 2 + # 301 already deleted — must not be retried; 302/303 remain for the retry. + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([302, 303], "@1") async def test_non_retryable_delete_failure_still_clears_tracking( self, mock_bot: AsyncMock @@ -198,11 +273,11 @@ async def test_non_retryable_delete_failure_still_clears_tracking( await _process_content_task(mock_bot, USER_ID, _task("tool_result", True)) # Gives up cleanly rather than retrying forever, and still tracks the new message. - assert _secondary_msg_info[(USER_ID, THREAD_ID)] == (101, "@1") + assert _secondary_msg_info[(USER_ID, THREAD_ID)] == ([101], "@1") class TestClearSecondaryMsgInfo: def test_clears_tracked_entry(self) -> None: - _secondary_msg_info[(USER_ID, THREAD_ID)] = (100, "@1") + _secondary_msg_info[(USER_ID, THREAD_ID)] = ([100], "@1") clear_secondary_msg_info(USER_ID, THREAD_ID) assert (USER_ID, THREAD_ID) not in _secondary_msg_info From ba13bfebeac74ab33af18fb71c93519de15dd1ef Mon Sep 17 00:00:00 2001 From: Mh Date: Tue, 15 Sep 2026 14:45:43 +0330 Subject: [PATCH 12/15] fix: don't let Claude Code's workspace trust dialog block new sessions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Since Claude Code ~2.1.260 the first launch in an untrusted directory shows an unnumbered "Quick safety check" menu whose default option is "No, exit". ccbot never answered it: the SessionStart hook doesn't fire, the 5s wait times out, and the pending first message is typed into the dialog — Enter on the default option exits Claude, leaving the topic bound to a bare shell. - claude_config.ensure_trusted_directory() sets projects[].hasTrustDialogAccepted = true in ~/.claude.json (honours CLAUDE_CONFIG_DIR) before creating the window. Atomic write, file mode preserved, no-op if already trusted, missing or malformed files left untouched. CCBOT_AUTO_TRUST_DIRS=false disables it. - Fallback for when the dialog still appears (e.g. the home directory, whose trust Claude Code doesn't persist): a TrustDialog UI pattern and TmuxManager.auto_answer_dialog(), which moves the ❯ cursor onto "Yes, I trust", re-captures to verify, then presses Enter. It never types a digit, since option order changed between versions. - _create_and_bind_window waits for Claude's input box (wait_for_claude_ready) before the hook wait and before forwarding the pending message; status polling answers the dialog in existing windows. Pane fixtures are real tmux captures from Claude Code 2.1.272. (cherry picked from commit 7aac525335586f1c532ffa17b80f97ca38a111e9) --- README.md | 1 + src/ccbot/bot.py | 10 ++ src/ccbot/claude_config.py | 101 ++++++++++++++++++ src/ccbot/config.py | 6 ++ src/ccbot/handlers/status_polling.py | 10 ++ src/ccbot/terminal_parser.py | 71 ++++++++++++ src/ccbot/tmux_manager.py | 66 ++++++++++++ tests/ccbot/fixtures/panes/ready_bypass.txt | 24 +++++ .../fixtures/panes/ready_manual_mode.txt | 24 +++++ tests/ccbot/fixtures/panes/trust_dialog.txt | 24 +++++ tests/ccbot/test_claude_config.py | 83 ++++++++++++++ tests/ccbot/test_trust_dialog.py | 96 +++++++++++++++++ 12 files changed, 516 insertions(+) create mode 100644 src/ccbot/claude_config.py create mode 100644 tests/ccbot/fixtures/panes/ready_bypass.txt create mode 100644 tests/ccbot/fixtures/panes/ready_manual_mode.txt create mode 100644 tests/ccbot/fixtures/panes/trust_dialog.txt create mode 100644 tests/ccbot/test_claude_config.py create mode 100644 tests/ccbot/test_trust_dialog.py diff --git a/README.md b/README.md index cbb5675a0..f9d0e5f4a 100644 --- a/README.md +++ b/README.md @@ -110,6 +110,7 @@ ALLOWED_USERS=your_telegram_user_id | `CLAUDE_COMMAND` | `claude` | Command to run in new windows | | `MONITOR_POLL_INTERVAL` | `2.0` | Polling interval in seconds | | `CCBOT_SHOW_HIDDEN_DIRS` | `false` | Show hidden (dot) directories in directory browser | +| `CCBOT_AUTO_TRUST_DIRS` | `true` | Mark the project trusted in `~/.claude.json` before launching `claude`, so the workspace trust dialog doesn't block new sessions | | `OPENAI_API_KEY` | _(none)_ | OpenAI API key for voice message transcription | | `OPENAI_BASE_URL` | `https://api.openai.com/v1` | OpenAI API base URL (for proxies or compatible APIs) | | `CCBOT_BATCH_WINDOW` | `10` | 🔱 Seconds before MessageBatcher emits a summary (`0` to disable batching) | diff --git a/src/ccbot/bot.py b/src/ccbot/bot.py index 28297f3af..e68170d07 100644 --- a/src/ccbot/bot.py +++ b/src/ccbot/bot.py @@ -60,6 +60,7 @@ filters, ) +from .claude_config import ensure_trusted_directory from .config import config from .skill_registry import SkillRegistry from .handlers.callback_data import ( @@ -1298,6 +1299,9 @@ async def _create_and_bind_window( assert isinstance(query, CallbackQuery) assert isinstance(user, User) + if config.auto_trust_dirs: + await asyncio.to_thread(ensure_trusted_directory, selected_path) + success, message, created_wname, created_wid = await tmux_manager.create_window( selected_path, resume_session_id=resume_session_id ) @@ -1311,6 +1315,12 @@ async def _create_and_bind_window( pending_thread_id, resume_session_id, ) + # Wait for Claude Code's input box first. This answers the workspace + # trust dialog if it still appears; the SessionStart hook only fires + # once Claude is past it, and a pending message must not be typed + # into the dialog (Enter on the default option exits Claude). + await tmux_manager.wait_for_claude_ready(created_wid, timeout=30.0) + # Wait for Claude Code's SessionStart hook to register in session_map. # Resume sessions take longer to start (loading session state), so use # a longer timeout to avoid silently dropping messages. diff --git a/src/ccbot/claude_config.py b/src/ccbot/claude_config.py new file mode 100644 index 000000000..42e23250b --- /dev/null +++ b/src/ccbot/claude_config.py @@ -0,0 +1,101 @@ +"""Helpers for Claude Code's own config file (~/.claude.json). + +Pre-trusts a working directory before launching `claude` in it so the +interactive "Quick safety check 
 Yes, I trust this folder" dialog never +appears. Since ~2.1.260 that dialog defaults to "No, exit", which left +bot-created sessions stuck at the prompt with the SessionStart hook never +firing. + +Key functions: + - claude_config_file(): path of ~/.claude.json (honours CLAUDE_CONFIG_DIR) + - trust_key_for(work_dir): the projects[] key Claude uses (git root or dir) + - ensure_trusted_directory(work_dir): set hasTrustDialogAccepted=true +""" + +import json +import logging +import os +import subprocess +from pathlib import Path +from typing import Any + +from .utils import atomic_write_json + +logger = logging.getLogger(__name__) + + +def claude_config_file() -> Path: + """Location of Claude Code's user config JSON.""" + config_dir = os.environ.get("CLAUDE_CONFIG_DIR", "") + if config_dir: + return Path(config_dir).expanduser() / ".claude.json" + return Path.home() / ".claude.json" + + +def trust_key_for(work_dir: str | Path) -> str: + """Return the ``projects`` key Claude Code trusts ``work_dir`` under. + + Trust is keyed on the git repository root (main checkout root for + worktrees); outside a repo, on the directory itself. + """ + path = Path(work_dir).expanduser().resolve() + try: + result = subprocess.run( + ["git", "-C", str(path), "rev-parse", "--show-toplevel"], + capture_output=True, + text=True, + timeout=5, + check=False, + ) + if result.returncode == 0 and result.stdout.strip(): + return str(Path(result.stdout.strip()).resolve()) + except (OSError, subprocess.SubprocessError): + pass + return str(path) + + +def ensure_trusted_directory(work_dir: str | Path) -> bool: + """Mark ``work_dir`` as trusted in ~/.claude.json. + + Returns True when the directory is trusted after the call (already + trusted or newly written), False when the config could not be updated + (missing/malformed file is left untouched — the pane-level dialog + handling in TmuxManager remains as the fallback). + """ + key = trust_key_for(work_dir) + cfg_path = claude_config_file() + if not cfg_path.exists(): + logger.info("No %s yet; skipping trust pre-accept for %s", cfg_path, key) + return False + try: + data: Any = json.loads(cfg_path.read_text(encoding="utf-8")) + except (OSError, ValueError) as e: + logger.warning("Cannot read %s (%s); not touching it", cfg_path, e) + return False + if not isinstance(data, dict): + logger.warning("%s is not a JSON object; not touching it", cfg_path) + return False + + projects = data.get("projects") + if projects is None: + projects = data["projects"] = {} + if not isinstance(projects, dict): + logger.warning("%s: 'projects' is not an object; not touching it", cfg_path) + return False + + entry = projects.get(key) + if isinstance(entry, dict) and entry.get("hasTrustDialogAccepted") is True: + return True + if not isinstance(entry, dict): + entry = projects[key] = {} + entry["hasTrustDialogAccepted"] = True + + try: + mode = cfg_path.stat().st_mode & 0o777 + atomic_write_json(cfg_path, data) + os.chmod(cfg_path, mode) + except OSError as e: + logger.warning("Failed to write %s: %s", cfg_path, e) + return False + logger.info("Pre-trusted %s in %s", key, cfg_path) + return True diff --git a/src/ccbot/config.py b/src/ccbot/config.py index d1b3e8a1c..f008c46f5 100644 --- a/src/ccbot/config.py +++ b/src/ccbot/config.py @@ -120,6 +120,12 @@ def __init__(self) -> None: # Set to 0.0 to disable batching (sends each message individually) self.batch_window = float(os.getenv("CCBOT_BATCH_WINDOW", "0.0")) + # Pre-trust directories in ~/.claude.json before launching claude, + # so Claude Code's workspace trust dialog doesn't block new sessions + self.auto_trust_dirs = ( + os.getenv("CCBOT_AUTO_TRUST_DIRS", "true").lower() != "false" + ) + # Show hidden (dot) directories in directory browser self.show_hidden_dirs = ( os.getenv("CCBOT_SHOW_HIDDEN_DIRS", "").lower() == "true" diff --git a/src/ccbot/handlers/status_polling.py b/src/ccbot/handlers/status_polling.py index a91651901..a359d7be5 100644 --- a/src/ccbot/handlers/status_polling.py +++ b/src/ccbot/handlers/status_polling.py @@ -29,6 +29,8 @@ from ..config import config from ..session import session_manager from ..terminal_parser import ( + AUTO_ANSWER_DIALOGS, + extract_interactive_content, is_interactive_ui, parse_codex_status_line, parse_status_line, @@ -183,6 +185,14 @@ async def update_status_message( # Clear stale interactive mode await clear_interactive_msg(user_id, bot, thread_id) + # Startup dialogs (workspace trust) are answered by the bot itself + # rather than rendered as a keyboard. + if should_check_new_ui: + ui = extract_interactive_content(pane_text) + if ui is not None and ui.name in AUTO_ANSWER_DIALOGS: + await tmux_manager.auto_answer_dialog(window_id, pane_text) + return + # Check for permission prompt (interactive UI not triggered via JSONL) # ALWAYS check UI, regardless of skip_status if should_check_new_ui and is_interactive_ui(pane_text): diff --git a/src/ccbot/terminal_parser.py b/src/ccbot/terminal_parser.py index 2bbe78c51..8c8ff0968 100644 --- a/src/ccbot/terminal_parser.py +++ b/src/ccbot/terminal_parser.py @@ -47,6 +47,17 @@ class UIPattern: # ── UI pattern definitions (order matters — first match wins) ──────────── UI_PATTERNS: list[UIPattern] = [ + UIPattern( + # Workspace trust dialog shown on first launch in a directory. + # Since ~2.1.260 the options are unnumbered and "No, exit" is the + # default, so an unanswered or blindly-confirmed dialog ends the session. + name="TrustDialog", + top=( + re.compile(r"^\s*Quick safety check"), + re.compile(r"^\s*Do you trust the files in this folder"), + ), + bottom=(re.compile(r"Enter to confirm"),), + ), UIPattern( name="ExitPlanMode", top=( @@ -122,6 +133,14 @@ class UIPattern: ] +# Dialogs the bot answers itself: name -> text of the option to select. +AUTO_ANSWER_DIALOGS: dict[str, str] = { + "TrustDialog": "Yes, I trust", +} + +_RE_MENU_CURSOR = re.compile(r"^\s*❯\s*\S") + + # ── Post-processing ────────────────────────────────────────────────────── _RE_LONG_DASH = re.compile(r"^─{5,}$") @@ -197,6 +216,58 @@ def is_interactive_ui(pane_text: str) -> bool: return extract_interactive_content(pane_text) is not None +def find_menu_option(pane_text: str, needle: str) -> tuple[int, int] | None: + """Locate the highlighted (``❯``) line and the option containing ``needle``. + + Returns ``(cursor_idx, option_idx)`` line indices; pressing Down + ``option_idx - cursor_idx`` times moves the cursor onto the option. + The option is searched from the bottom (dialogs render at the end of the + pane) and the cursor is the ``❯`` nearest to it, so an earlier shell + prompt such as ``❯ claude`` is never mistaken for the menu cursor. + """ + lines = pane_text.split("\n") + option_idx = next( + (i for i in range(len(lines) - 1, -1, -1) if needle in lines[i]), None + ) + if option_idx is None: + return None + lo, hi = max(0, option_idx - 10), min(len(lines), option_idx + 11) + cursor_idx = min( + (i for i in range(lo, hi) if _RE_MENU_CURSOR.match(lines[i])), + key=lambda i: abs(i - option_idx), + default=None, + ) + if cursor_idx is None: + return None + return cursor_idx, option_idx + + +def _is_separator(line: str) -> bool: + stripped = line.strip() + return len(stripped) >= 20 and all(c == "─" for c in stripped) + + +def is_prompt_ready(pane_text: str) -> bool: + """True when Claude Code shows its idle input box. + + Layout at the bottom of the pane:: + + ──────────────── (separator) + ❯ 
 (input line) + ──────────────── (separator) + ⏵⏵ 
 (footer) + """ + if not pane_text: + return False + tail = pane_text.rstrip().split("\n")[-8:] + for i in range(len(tail) - 2): + if not _is_separator(tail[i]) or not tail[i + 1].lstrip().startswith("❯"): + continue + if any(_is_separator(tail[j]) for j in range(i + 2, min(i + 5, len(tail)))): + return True + return False + + # ── Status line parsing ───────────────────────────────────────────────── # Spinner characters Claude Code uses in its status line diff --git a/src/ccbot/tmux_manager.py b/src/ccbot/tmux_manager.py index 969f28a87..e1c759b41 100644 --- a/src/ccbot/tmux_manager.py +++ b/src/ccbot/tmux_manager.py @@ -18,12 +18,19 @@ import re import secrets import subprocess +import time from dataclasses import dataclass from pathlib import Path import libtmux from .config import SENSITIVE_ENV_VARS, config +from .terminal_parser import ( + AUTO_ANSWER_DIALOGS, + extract_interactive_content, + find_menu_option, + is_prompt_ready, +) logger = logging.getLogger(__name__) @@ -364,6 +371,65 @@ def _send_enter() -> bool: await asyncio.sleep(0.5) return await asyncio.to_thread(_send_enter) + async def auto_answer_dialog(self, window_id: str, pane_text: str) -> str | None: + """Answer a startup dialog the bot handles itself (workspace trust). + + Moves the ``❯`` cursor onto the wanted option with Up/Down, re-captures + to verify it landed there, then presses Enter. Never types a digit — + the option order has changed between Claude Code versions. + + Returns the dialog name when answered, else None. + """ + ui = extract_interactive_content(pane_text) + if ui is None or ui.name not in AUTO_ANSWER_DIALOGS: + return None + needle = AUTO_ANSWER_DIALOGS[ui.name] + offsets = find_menu_option(pane_text, needle) + if offsets is None: + logger.warning("%s in %s: option %r not found", ui.name, window_id, needle) + return None + cursor, target = offsets + steps = target - cursor + key = "Down" if steps > 0 else "Up" + for _ in range(abs(steps)): + await self.send_keys(window_id, key, enter=False, literal=False) + await asyncio.sleep(0.15) + if steps: + await asyncio.sleep(0.3) + check = find_menu_option(await self.capture_pane(window_id) or "", needle) + if check is None or check[0] != check[1]: + logger.warning( + "%s in %s: cursor did not reach %r, not confirming", + ui.name, + window_id, + needle, + ) + return None + await self.send_keys(window_id, "Enter", enter=False, literal=False) + logger.info("Answered %s in %s with %r", ui.name, window_id, needle) + return ui.name + + async def wait_for_claude_ready( + self, window_id: str, timeout: float = 30.0 + ) -> bool: + """Wait until Claude Code shows its input box, answering startup dialogs. + + Returns False on timeout (the caller still proceeds; this only avoids + typing the first message into a dialog or a half-started TUI). + """ + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + pane = await self.capture_pane(window_id) + if pane: + if is_prompt_ready(pane): + return True + if await self.auto_answer_dialog(window_id, pane): + await asyncio.sleep(1.0) + continue + await asyncio.sleep(0.5) + logger.warning("Claude Code not ready in %s after %.0fs", window_id, timeout) + return False + async def send_keys( self, window_id: str, diff --git a/tests/ccbot/fixtures/panes/ready_bypass.txt b/tests/ccbot/fixtures/panes/ready_bypass.txt new file mode 100644 index 000000000..15ab75f61 --- /dev/null +++ b/tests/ccbot/fixtures/panes/ready_bypass.txt @@ -0,0 +1,24 @@ + + ▐▛███▛█ Claude Code v2.1.272 +▝▜██████▀ Opus 5 with high effort · Claude Pro + ▝▝ ▝▝ /private/tmp + + + + + + + + + + + + + + + + ● high · /effort +──────────────────────────────────────────────────────────────────────────────── +❯  +──────────────────────────────────────────────────────────────────────────────── + ⏵⏵ bypass permissions on (shift+tab to cycle) · ← for agents diff --git a/tests/ccbot/fixtures/panes/ready_manual_mode.txt b/tests/ccbot/fixtures/panes/ready_manual_mode.txt new file mode 100644 index 000000000..91e39b686 --- /dev/null +++ b/tests/ccbot/fixtures/panes/ready_manual_mode.txt @@ -0,0 +1,24 @@ + + + Ran 1 shell command + +⏺ Darwin host.local 25.3.0 Darwin Kernel Version 25.3.0: Wed Jan 28 20:53:14 + PST 2026; root:xnu-12377.81.4~5/RELEASE_X86_64 x86_64 + +✻ Worked for 5s · done 1:49 PM + +❯ Create a file /tmp/ccbot-test-perm.txt containing the single word hello, + using the Write tool. + +⏺ Write(/tmp/ccbot-test-perm.txt) + ⎿  Wrote 1 line to ../../tmp/ccbot-test-perm.txt + 1 hello + +⏺ Created /tmp/ccbot-test-perm.txt containing hello. + +✻ Churned for 4s · done 1:50 PM + +──────────────────────────────────────────────────────────────────────────────── +❯ Read the file back with the Read tool +──────────────────────────────────────────────────────────────────────────────── + ⏞ manual mode on · ? for shortcuts · ← for agents diff --git a/tests/ccbot/fixtures/panes/trust_dialog.txt b/tests/ccbot/fixtures/panes/trust_dialog.txt new file mode 100644 index 000000000..e89a99c2e --- /dev/null +++ b/tests/ccbot/fixtures/panes/trust_dialog.txt @@ -0,0 +1,24 @@ + /tmp à­šà­§ Mh  01:44:07 PM +❯ claude + +──────────────────────────────────────────────────────────────────────────────── + Accessing workspace: + + /private/tmp + + Quick safety check: Is this a project you created or one you trust? (Like your + own code, a well-known open source project, or work from your team). If not, + take a moment to review what's in this folder first. + + Claude Code'll be able to read, edit, and execute files here. + + Security guide + + ❯ No, exit + Yes, I trust this folder + + Enter to confirm · Esc to cancel + + + + diff --git a/tests/ccbot/test_claude_config.py b/tests/ccbot/test_claude_config.py new file mode 100644 index 000000000..3b6480d93 --- /dev/null +++ b/tests/ccbot/test_claude_config.py @@ -0,0 +1,83 @@ +"""Tests for claude_config.ensure_trusted_directory.""" + +import json +import subprocess + +import pytest + +import ccbot.claude_config as cc + + +@pytest.fixture +def cfg(tmp_path, monkeypatch): + path = tmp_path / ".claude.json" + monkeypatch.setattr(cc, "claude_config_file", lambda: path) + # No git: key is the directory itself + monkeypatch.setattr( + cc.subprocess, + "run", + lambda *a, **k: subprocess.CompletedProcess(a, 128, stdout="", stderr=""), + ) + return path + + +class TestEnsureTrustedDirectory: + def test_adds_entry_and_keeps_other_keys(self, cfg, tmp_path): + cfg.write_text(json.dumps({"theme": "dark", "projects": {"/x": {"a": 1}}})) + cfg.chmod(0o600) + work = tmp_path / "proj" + work.mkdir() + assert cc.ensure_trusted_directory(work) is True + data = json.loads(cfg.read_text()) + assert data["theme"] == "dark" + assert data["projects"]["/x"] == {"a": 1} + assert data["projects"][str(work.resolve())] == {"hasTrustDialogAccepted": True} + assert cfg.stat().st_mode & 0o777 == 0o600 + + def test_noop_when_already_trusted(self, cfg, tmp_path): + work = tmp_path / "proj" + work.mkdir() + cfg.write_text( + json.dumps( + {"projects": {str(work.resolve()): {"hasTrustDialogAccepted": True}}} + ) + ) + before = cfg.read_text() + assert cc.ensure_trusted_directory(work) is True + assert cfg.read_text() == before + + def test_existing_entry_gets_flag(self, cfg, tmp_path): + work = tmp_path / "proj" + work.mkdir() + key = str(work.resolve()) + cfg.write_text( + json.dumps({"projects": {key: {"hasTrustDialogAccepted": False, "k": 2}}}) + ) + assert cc.ensure_trusted_directory(work) is True + data = json.loads(cfg.read_text()) + assert data["projects"][key] == {"hasTrustDialogAccepted": True, "k": 2} + + def test_missing_file_untouched(self, cfg, tmp_path): + assert cc.ensure_trusted_directory(tmp_path) is False + assert not cfg.exists() + + def test_malformed_file_untouched(self, cfg, tmp_path): + cfg.write_text("{not json") + assert cc.ensure_trusted_directory(tmp_path) is False + assert cfg.read_text() == "{not json" + + def test_git_root_used_as_key(self, cfg, tmp_path, monkeypatch): + cfg.write_text(json.dumps({"projects": {}})) + root = tmp_path / "repo" + sub = root / "src" / "pkg" + sub.mkdir(parents=True) + monkeypatch.setattr( + cc.subprocess, + "run", + lambda *a, **k: subprocess.CompletedProcess( + a, 0, stdout=f"{root}\n", stderr="" + ), + ) + assert cc.ensure_trusted_directory(sub) is True + data = json.loads(cfg.read_text()) + assert list(data["projects"]) == [str(root.resolve())] diff --git a/tests/ccbot/test_trust_dialog.py b/tests/ccbot/test_trust_dialog.py new file mode 100644 index 000000000..774a7cac7 --- /dev/null +++ b/tests/ccbot/test_trust_dialog.py @@ -0,0 +1,96 @@ +"""Tests for workspace-trust dialog detection and auto-answering. + +Fixtures are real `tmux capture-pane` outputs from Claude Code 2.1.272. +""" + +from pathlib import Path +from unittest.mock import AsyncMock + +import pytest + +import ccbot.tmux_manager as tm +from ccbot.terminal_parser import ( + extract_interactive_content, + find_menu_option, + is_prompt_ready, +) + +FIXTURES = Path(__file__).parent / "fixtures" / "panes" + + +def load(name: str) -> str: + return (FIXTURES / name).read_text(encoding="utf-8") + + +class TestDetection: + def test_trust_dialog_detected(self): + ui = extract_interactive_content(load("trust_dialog.txt")) + assert ui is not None + assert ui.name == "TrustDialog" + assert "Yes, I trust this folder" in ui.content + + def test_trust_dialog_is_not_prompt_ready(self): + assert not is_prompt_ready(load("trust_dialog.txt")) + + @pytest.mark.parametrize("name", ["ready_bypass.txt", "ready_manual_mode.txt"]) + def test_ready_prompt(self, name): + pane = load(name) + assert is_prompt_ready(pane) + assert extract_interactive_content(pane) is None + + def test_option_is_one_below_cursor(self): + # "❯ No, exit" is highlighted; the shell's "❯ claude" line above + # must not be taken for the menu cursor. + offsets = find_menu_option(load("trust_dialog.txt"), "Yes, I trust") + assert offsets is not None + cursor, option = offsets + assert option - cursor == 1 + + def test_missing_option(self): + assert find_menu_option(load("trust_dialog.txt"), "nope") is None + + +class TestAutoAnswer: + @pytest.fixture + def mgr(self, monkeypatch): + monkeypatch.setattr(tm.asyncio, "sleep", AsyncMock()) + m = tm.TmuxManager(session_name="ccbot") + m.send_keys = AsyncMock(return_value=True) # type: ignore[method-assign] + return m + + @staticmethod + def _moved(pane: str) -> str: + return pane.replace(" ❯ No, exit", " No, exit").replace( + " Yes, I trust this folder", " ❯ Yes, I trust this folder" + ) + + @pytest.mark.asyncio + async def test_moves_down_verifies_then_enter(self, mgr): + pane = load("trust_dialog.txt") + mgr.capture_pane = AsyncMock(return_value=self._moved(pane)) # type: ignore[method-assign] + assert await mgr.auto_answer_dialog("@1", pane) == "TrustDialog" + keys = [c.args[1] for c in mgr.send_keys.await_args_list] + assert keys == ["Down", "Enter"] + + @pytest.mark.asyncio + async def test_does_not_confirm_if_cursor_did_not_move(self, mgr): + pane = load("trust_dialog.txt") + mgr.capture_pane = AsyncMock(return_value=pane) # type: ignore[method-assign] + assert await mgr.auto_answer_dialog("@1", pane) is None + keys = [c.args[1] for c in mgr.send_keys.await_args_list] + assert "Enter" not in keys + + @pytest.mark.asyncio + async def test_ignores_other_panes(self, mgr): + assert await mgr.auto_answer_dialog("@1", load("ready_bypass.txt")) is None + mgr.send_keys.assert_not_awaited() + + @pytest.mark.asyncio + async def test_wait_for_ready_answers_dialog(self, mgr): + trust = load("trust_dialog.txt") + mgr.capture_pane = AsyncMock( # type: ignore[method-assign] + side_effect=[trust, self._moved(trust), load("ready_bypass.txt")] + ) + assert await mgr.wait_for_claude_ready("@1", timeout=5) is True + keys = [c.args[1] for c in mgr.send_keys.await_args_list] + assert keys == ["Down", "Enter"] From 666b3a21a62dce56e6b4211f5f936b332a0d15cf Mon Sep 17 00:00:00 2001 From: Mh Date: Tue, 15 Sep 2026 15:00:24 +0330 Subject: [PATCH 13/15] fix: treat session-name labelled borders as the input box separator MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Named sessions render the input box's top border as '──────── my-session ─', which the plain all-dashes check rejected, so wait_for_claude_ready timed out on otherwise-ready sessions. Fixture is a real 2.1.272 capture. (cherry picked from commit e45d2817bc8653e79b42d5acd275d51d8b50429a) --- src/ccbot/terminal_parser.py | 9 +++- .../panes/ready_labelled_separator.txt | 51 +++++++++++++++++++ tests/ccbot/test_trust_dialog.py | 5 +- 3 files changed, 63 insertions(+), 2 deletions(-) create mode 100644 tests/ccbot/fixtures/panes/ready_labelled_separator.txt diff --git a/src/ccbot/terminal_parser.py b/src/ccbot/terminal_parser.py index 8c8ff0968..a0067b00a 100644 --- a/src/ccbot/terminal_parser.py +++ b/src/ccbot/terminal_parser.py @@ -243,8 +243,15 @@ def find_menu_option(pane_text: str, needle: str) -> tuple[int, int] | None: def _is_separator(line: str) -> bool: + """A chrome border line. + + Named sessions (--resume , --name, /rename) put the name in the + input box's top border: "──────── my-session ─" (one trailing dash). + """ stripped = line.strip() - return len(stripped) >= 20 and all(c == "─" for c in stripped) + if len(stripped) < 20 or not stripped.startswith("────"): + return False + return stripped.endswith("─") and stripped.count("─") / len(stripped) >= 0.6 def is_prompt_ready(pane_text: str) -> bool: diff --git a/tests/ccbot/fixtures/panes/ready_labelled_separator.txt b/tests/ccbot/fixtures/panes/ready_labelled_separator.txt new file mode 100644 index 000000000..48ce047f2 --- /dev/null +++ b/tests/ccbot/fixtures/panes/ready_labelled_separator.txt @@ -0,0 +1,51 @@ + + ✕ +● Everything I need is done except committing the docs. Two things remain, both depending only on the + edit that just landed: a structural sanity check on the file, and the commit/push. I'll chain them so + the commit only runs if the file still parses as expected. + + Thought for 7s, committed 11d9edc, pushed to main + +● Nothing further needed — the work is complete and verified end to end. Both commits are pushed. + + Done: TON sweep floor 0.2 → 0.05 + + The change — MIN_TRANSFER_THRESHOLD: "0.05" on the x-ton-shkeeper-env anchor in + deploy/shkeeper/docker-compose.yml. It wasn't in any of our files before: the image reads it from the + environment with the default baked in (config.py:45), which is why grepping the repo and .env found + nothing. Synced to /root/shkeeper/shkeeper/ with matching checksums, YAML validated, and confirmed to + render into both ton-shkeeper and ton-shkeeper-worker — the worker matters, it's what runs the drain. + + It worked on the real stranded payment. Invoice 17 swept on the first triggered run: + + - 197172600 → 0 nanotons, txid 1c7b1261
, task status: 'success' + - forwarded on to the payout wallet, payout #10 → SUCCESS + - invoice 11 (0.00342317) correctly left alone — worth less than the gas to move + + Two things I checked that could have gone wrong quietly: No changes this session + + The fee-deposit wallet barely moved (+41 nanotons), which looks like a failed sweep. It isn't — + wallet.ppolicy=LIMIT with pcond=0.1 auto-forwards anything over 0.1 TON straight to wallet.pdest. I + confirmed that destination against the wallet table rather than inferring it from history, since money + was moving to an address I hadn't verified. + + The scanner kept its place across the restart: gap 10 blocks, zero 404/500/429. + + One decision left with you: jettons use a separate floor, MIN_TOKEN_TRANSFER_THRESHOLD, still at its + default 0.5 — and that's USDT, not TON. I deliberately didn't touch it, since "0.05" in a different + unit is a different call. Say the word if you want TON-USDT lowered too. + + Commits: 74a4e0a (config), 11d9edc (lessons). + + Two corrections worth recording about my own work here. I claimed a scanner gap of -92,846,348 + mid-session — that was my parse bug, not a fault: getMasterchainInfo returns an init block with + "seqno":0 after the real one and my tail -1 grabbed the zero. And I'd believed that trap was already + in agent-lessons.md from earlier this session; it never actually got written, which is exactly why I + repeated it. Both are now entries in the file. + +✻ Baked for 12m 20s · done 12:41 PM + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── royal-vpn-main ─ +❯  +───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + ⏵⏵ accept edits on (shift+tab to cycle) · ← for agents diff --git a/tests/ccbot/test_trust_dialog.py b/tests/ccbot/test_trust_dialog.py index 774a7cac7..120c441aa 100644 --- a/tests/ccbot/test_trust_dialog.py +++ b/tests/ccbot/test_trust_dialog.py @@ -32,7 +32,10 @@ def test_trust_dialog_detected(self): def test_trust_dialog_is_not_prompt_ready(self): assert not is_prompt_ready(load("trust_dialog.txt")) - @pytest.mark.parametrize("name", ["ready_bypass.txt", "ready_manual_mode.txt"]) + @pytest.mark.parametrize( + "name", + ["ready_bypass.txt", "ready_manual_mode.txt", "ready_labelled_separator.txt"], + ) def test_ready_prompt(self, name): pane = load(name) assert is_prompt_ready(pane) From 80415c96bfa2c6a370b79c8a6936f7c4e19649d6 Mon Sep 17 00:00:00 2001 From: TejNote Date: Wed, 16 Sep 2026 12:32:05 +0900 Subject: [PATCH 14/15] =?UTF-8?q?chore(release):=20v1.1.0=20=E2=80=94=20up?= =?UTF-8?q?stream=20=EC=BB=A4=EB=AE=A4=EB=8B=88=ED=8B=B0=20PR=209=EA=B1=B4?= =?UTF-8?q?=20=EC=84=A0=EB=B3=84=20=EB=A8=B8=EC=A7=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit upstream main 은 2026-07-08 읎후 멈춰 있고 읎 fork 는 읎믞 완전 동Ʞ화 상태였닀. ë‚šì•„ 있던 걎 믞뚞지 컀뮀니티 PR 뿐읎띌 귞쀑 9걎을 곚띌 가젞왔닀. Tested: pytest 432항 (뚞지 전 400) · pyright 0 errors · ruff 위반 103 → 101 Co-Authored-By: Claude Opus 5 (1M context) --- CHANGELOG.md | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++ pyproject.toml | 2 +- 2 files changed, 75 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c5c5c5f71..082432c1a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,80 @@ --- +## [1.1.0] - 2026-09-16 + +upstream 컀뮀니티 PR 9걎을 선별 뚞지한닀. **upstream `main` 은 2026-07-08 읎후 멈춰 있고 +읎 fork 는 읎믞 완전 동Ʞ화 상태**띌(`git rev-list --count <마지막뚞지>..upstream/main` = 0), +가젞올 게 ë‚šì•„ 있던 곳은 **뚞지되지 않은 컀뮀니티 PR** 뿐읎었닀. + +upstream 의 믞뚞지 람랜치 3개(`fix/prevent-window-rename` · `fix/restore-telegramify-markdown-default` +· `fix/scrub-sensitive-env`)는 `git cherry` 로 확읞한 결곌 **전부 읎믞 팚치 동등하게 적용**돌 +있었닀(SHA 만 닀륞 PR 잔핎). `copilot/*` 는 main 읎전의 폐Ʞ된 늬팩터링읎닀. +`codex/codex-remote-agents`(+3,120쀄)는 Codex 륌 app-server WebSocket 원격 프로토윜로 닀시 +붙읎는 싀험 람랜치띌 읎 fork 의 OMX 로컬 tmux 방식곌 ì •ë©Ž 충돌핎 **제왞**했닀. + +### Fixed + +- **음시적 였류에도 평묞윌로 재전송핎 메시지가 두 번 가던 것** (upstream #93) + - `except Exception` 하나로 전부 잡아 평묞 재전송했닀. `TimedOut`·`NetworkError` 는 + **읎믞 도착했을 수도 있는** 몚혞한 상태띌, 재전송하멎 서식볞 + 평묞볞 2걎읎 된닀 + - 읎제 `BadRequest`(= 텔레귞랚읎 서식을 거부 → 확싀히 믞전달)음 때만 평묞윌로 닀시 볎낞닀 +- **ì ‘êž° 읞용읎 깚젞 원묞읎 통짞로 쏟아지던 것** (upstream #94) + - `_render_expandable_quote()` 가 `>line
||` 륌 만듀었는데, 텔레귞랚 묞법은 첫 쀄에 + `**>` 륌 요구한닀. 없윌멎 끝의 `||` 가 짝 없는 spoiler 띌 `Can't parse entities` 로 + 전첎가 거부되고, 폎백읎 **서식 없는 평묞 전묞**을 귞대로 볎낞닀 + - thinking · Bash/Grep/Glob/Task/WebFetch 결곌 · 여러 쀄 에러 · Edit diff 가 전부 읎 겜로닀. + "N쀄, 탭핎서 펌치Ʞ" 대신 로귞 원묞읎 맀번 채팅에 떚얎지고 있었닀 +- **상태쀄 아래 tip 랔록읎 끌멎 상태륌 놓치던 것** (upstream #97) + - 구분선 바로 윗쀄만 볎던 로직읎 tip 랔록에 막혔닀. 위로 더 훑되, 읞접하지 않은 위치에서는 + `
` 륌 가진 쀄만 상태로 읞정한닀(음반 출력의 `·` 불늿곌 완료 표시 `✻ Sautéed for 7s` 제왞) +- **타읎핑 표시가 ꞎ 구간에서 꺌지던 것** (upstream #98) + - 텔레귞랚은 chat action 을 ì•œ 5쎈 ë’€ 지욎닀. 상태 메시지륌 볎낌 때만 한 번 쏘던 방식읎띌 + 상태 텍슀튞가 안 바뀌는 동안 표시가 사띌졌닀. 읎제 상태폎링읎 4쎈 죌Ʞ keepalive 로 몬닀 +- **포럌 토픜에서 "/" 메뉎가 비얎 볎읎던 것** (upstream #99) + - 큎띌읎얞튞는 ê·ž 채팅에 맞는 **슀윔프**륌 읜고, 좁은 슀윔프가 Ʞ볞을 읎ꞎ닀. 옛 섀정읎 + 낚ꞎ `all_private_chats` 목록 하나가 진짜 메뉎륌 가렞닀. 지욞 땐 ꎀ늬자 슀윔프까지 넓게, + ì“ž 땐 싀제로 쓰는 슀윔프 전부에 ì“Žë‹€ +- **워크슀페읎슀 신뢰 대화상자가 새 섞션을 막던 것** (upstream #101) + - `claude` 싀행 전 `~/.claude.json` 에 핎당 디렉터늬륌 신뢰 표시한닀. + 끄렀멎 `CCBOT_AUTO_TRUST_DIRS=false` +- **ì„žì…˜ 읎늄읎 박힌 테두늬륌 입력찜 구분선윌로 못 읜던 것** (upstream #101) +- **죜은 토픜 상태가 쌓읎던 것** (upstream #81) — `/kill` 읎 메뉎 힌튞로만 등록돌 있얎 핞듀러 + 없읎 Claude Code 로 흘러듀얎갔닀. 싀제 핞듀러륌 붙읎고, 토픜읎 `/kill` 밖에서 죜었을 때도 + 같은 정늬 겜로륌 타게 했닀 + +### Added + +- **볎조 메시지 자동 정늬** (upstream #94) — thinking · tool_use/tool_result · 로컬 명령 에윔 · + 사용자 메시지 되욞늌읎 영원히 쌓여 **진짜 답변을 묻었닀.** 토픜별로 마지막 "볎조" 메시지륌 + 추적핎 닀음 메시지가 였멎 지욎닀. 최종 답변은 추적도 삭제도 하지 않윌므로, 턎읎 끝나멎 + 자연히 답변만 낚는닀. 병합 태슀크·분할 전송은 메시지가 여러 개띌 **id 목록**윌로 추적한닀 +- **타읎뚞 상태 갱신 적응형 슀로틀** (upstream #52) — 레읎튞 늬밋 회플 +- **음성 전사 몚덞 섀정** (upstream #91) — OpenAI 혾환 백엔드용 + +### 읎 fork 에 맞춰 손볞 것 + +- #98 — upstream 은 chat action 에 thread 륌 안 싣는닀. 읎 fork 는 토픜 몚드가 Ʞ볞읎띌 + `_send_kwargs` 로 `message_thread_id` 륌 넘ꞎ닀. codex 분Ʞ도 같은 게읎튞륌 탄닀 +- #99 — upstream 은 `post_init` 2곳만 고쳀지만 읎 fork 는 슀킬 슐겚찟Ʞ 토Ꞁ에서 런타임 + 재등록을 한 번 더 한닀. 거Ʞ까지 같은 헬퍌륌 태워알 토Ꞁ ë’€ 메뉎가 되돌아가지 않는닀 +- #94 — upstream 은 윘텐잠 처늬 끝에서 `_check_and_send_status` 륌 읞띌읞 혞출한닀. + 읎 fork 는 상태 표시륌 `status_polling` 에 넘Ʞ며 ê·ž 혞출을 뺐윌므로 되삎늬지 않았닀 +- #81 + #93 — 죜은 토픜 정늬(`_maybe_cleanup_dead_topic`)는 `BadRequest` 분Ʞ 안쪜에만 둔닀. + `Topic_id_invalid`·`Message thread not found` 는 `BadRequest` 로 였고, `TimedOut` 윌로 + 토픜을 지우멎 넀튞워크가 흔듀늎 때마닀 멀쩡한 바읞딩읎 ë‚ ì•„ê°„ë‹€ +- #97 — fork 고유의 백귞띌욎드 ì…ž 필터(`_BACKGROUND_SHELL_RE`)륌 볎졎했닀 +- #99 — `CC_COMMANDS` 에 upstream 읎 추가한 5개(agents·context·recap·status·tasks)륌 넣되 + 섀명은 읎 fork 의 한국얎 슀타음로 맞췄닀 + +### 검슝 + +- `pytest` **432항 통곌** (뚞지 전 400항 → upstream 테슀튞 32항 추가) +- `pyright src/ccbot/` **0 errors** +- `ruff check src/ tests/` 위반 **103 → 101** (슝가 없음. 낚은 것은 main 에도 있던 êž°ì¡Ž 부채) + +--- + ## [1.0.10] - 2026-09-04 libtmux 의 찜·pane 엎거륌 우회핎 `zip() argument 2 is shorter than argument 1` 을 없앀닀. diff --git a/pyproject.toml b/pyproject.toml index 8649fabb6..c78203494 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "ccbot" -version = "1.0.10" +version = "1.1.0" description = "Telegram Bot for monitoring Claude Code sessions" readme = "README.md" requires-python = ">=3.12" From 3cee43840ebf8ff27e07fbfc389f6861091facc7 Mon Sep 17 00:00:00 2001 From: TejNote Date: Wed, 16 Sep 2026 12:50:44 +0900 Subject: [PATCH 15/15] =?UTF-8?q?fix(merge):=20=EB=A6=AC=EB=B7=B0=EA=B0=80?= =?UTF-8?q?=20=EC=9E=A1=EC=9D=80=20=EB=A8=B8=EC=A7=80=20=EA=B2=B0=ED=95=A8?= =?UTF-8?q?=206=EA=B1=B4=20=E2=80=94=20=ED=83=80=EC=9D=B4=ED=95=91=20?= =?UTF-8?q?=EB=AC=B4=ED=95=9C=20=ED=98=B8=EC=B6=9C=C2=B7=EB=B6=88=EB=A6=BF?= =?UTF-8?q?=20=EC=98=A4=ED=83=90=C2=B7=EC=9D=B4=EB=AF=B8=EC=A7=80=20?= =?UTF-8?q?=EA=B3=A0=EC=95=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit upstream 팚치 자첎는 맞지만 **읎 fork 의 닀륞 부분곌 겹쳐서 깚지는** 것듀읎닀. upstream 테슀튞로는 안 잡힌닀. 🚚 죜은 토픜 정늬 후 타읎핑 keepalive 가 ì‚Žì•„ë‚šì•„ 묎한 API 혞출 #81 의 cleanup_dead_topic 은 clear_topic_state 륌 부륎지 않는 유음한 í•Žì œ 겜로였닀 (닀륞 셋은 전부 부륞닀). #98 전에는 닚순 누수였지만 붙고 나서는 _typing_keepalive 가 while True 띌 **텔레귞랚읎 "ê·ž 토픜 없닀" ê³  답한 thread 로 4쎈마닀 send_chat_action 을 영원히** 던지게 됐닀. 정늬한 (user_id, thread_id) 목록을 반환하도록 바꿔 연결한닀. #97 의 8쀄 슀캔읎 `·` 불늿을 상태쀄로 읜는 구멍을 비읞접 쀄에 엎었닀 upstream 조걎읎 `"
" in line` 하나뿐읞데 `·` 는 슀플너읎멎서 평범한 불늿읎닀. Claude 답변의 `· 첫짞 항목은 ` 읎 상태쀄읎 되고, #98 읎 ê·ž 값윌로 타읎핑을 쌜므로 유휎 섞션에 유령 상태 메시지 + 영구 타읎핑읎 낚는닀. 비읞접은 `
` **귞늬고** `·` 아님. ⚠ 구분선 바로 위 불늿은 main 에도 있던 êž°ì¡Ž 였탐읎띌 손대지 않았닀(싀잡 대조). 퍌믞션 프롬프튞 동안 "작업 쀑" 윌로 볎읎던 것 #98 의 set_typing 읎 핚수 맚 끝 한 번읞데 ê·ž 위에 ì¡°êž° return 읎 셋읎닀. 프롬프튞는 몇 시간도 떠 있고 싀제로는 뎇읎 사용자륌 Ʞ닀늬는 쀑읎닀. skip_status 는 제왞했닀 — 큐가 ì°¬ 음시적 상태읎고 에읎전튞는 싀제로 작업 쀑읎닀. secondary 태슀크의 읎믞지가 고아로 낹던 것 #94 가 몚윌는 id 에 _send_task_images 의 사진읎 빠졌닀. tool_result 는 항상 secondary 띌 닀음 메시지가 였멎 섀명 텍슀튞만 지워지고 슀크늰샷읎 낚는닀. send_photo 가 id 륌 반환한닀. 윜백 응답읎 최대 45쎈 지연되던 것 query.answer() 앞에 wait_for_claude_ready(30쎈) + wait_for_session_map_entry(5~15쎈)가 있었닀. 텔레귞랚은 ì•œ 15쎈륌 넘Ʞ멎 query is too old 륌 ë‚Žê³  try/except 도 없닀. 응답을 맚 앞윌로 옮게닀 — 결곌는 safe_edit 가 볞묞윌로 볎여쀀닀. TOPIC_CHECK_INTERVAL docstring 60쎈 → 5쎈 정정 ⚠ 바읞딩당 API 혞출 12배로 #52 슀로틀곌 방향읎 반대닀. 레읎튞 늬밋을 싀제로 맞은 ꎀ잡읎 없얎 upstream 값은 유지하고, 귌거와 되돌멮 값(15~20쎈)을 죌석에 낚게닀. Tested: pytest 440항 (신규 8) · pyright 0 errors · ruff 103 → 102, 파음·규칙 닚위로 main 에 없던 조합 0걎. 신규 테슀튞는 **뮀테읎션 4종**윌로 유횚성을 확읞했닀 — 각 수정을 되돌늬멎 대응 테슀튞 하나씩만 싀팚한닀. Not-tested: 싀제 텔레귞랚 대상 수동 검슝(뮇 재시작 필요 — 뚞지 후 별도) Co-Authored-By: Claude Opus 5 (1M context) --- CHANGELOG.md | 39 ++++- src/ccbot/bot.py | 10 +- src/ccbot/handlers/message_queue.py | 18 ++- src/ccbot/handlers/message_sender.py | 46 ++++-- src/ccbot/handlers/status_polling.py | 21 ++- src/ccbot/session.py | 25 ++- src/ccbot/terminal_parser.py | 29 +++- tests/ccbot/test_upstream_merge_fixes.py | 184 +++++++++++++++++++++++ 8 files changed, 330 insertions(+), 42 deletions(-) create mode 100644 tests/ccbot/test_upstream_merge_fixes.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 082432c1a..f6b028393 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -80,11 +80,46 @@ upstream 의 믞뚞지 람랜치 3개(`fix/prevent-window-rename` · `fix/restor - #99 — `CC_COMMANDS` 에 upstream 읎 추가한 5개(agents·context·recap·status·tasks)륌 넣되 섀명은 읎 fork 의 한국얎 슀타음로 맞췄닀 +### 뚞지 후 늬뷰에서 잡아 고친 것 + +upstream 팚치 자첎는 맞지만 **읎 fork 의 닀륞 부분곌 겹쳐서 깚지는** 것듀읎닀. +upstream 테슀튞로는 안 잡힌닀. 전부 `tests/ccbot/test_upstream_merge_fixes.py` 로 고정했고, +수정을 되돌늬는 뮀테읎션 4종읎 각각 핎당 테슀튞 하나씩을 싀팚시킀는 것까지 확읞했닀. + +- 🚚 **죜은 토픜을 정늬핎도 타읎핑 keepalive 가 ì‚Žì•„ë‚šì•„ 묎한 API 혞출** — #81 의 + `cleanup_dead_topic` 은 ì„žì…˜ 상태만 풀고 `clear_topic_state` 륌 부륎지 않는 **유음한** + í•Žì œ 겜로였닀(닀륞 셋은 전부 부륞닀). #98 읎 붙Ʞ 전에는 닚순 누수였지만, 붙고 나서는 + `_typing_keepalive` 가 `while True` 띌 **텔레귞랚읎 "ê·ž 토픜 없닀" ê³  답한 thread 로 + 4쎈마닀 `send_chat_action` 을 영원히** 던지게 됐닀. `cleanup_dead_topic` 읎 정늬한 + `(user_id, thread_id)` 목록을 돌렀죌도록 바꟞고 혞출처에서 `clear_topic_state` 륌 돌늰닀 +- **#97 의 8쀄 슀캔읎 `·` 불늿을 상태쀄로 읜는 구멍을 비읞접 쀄에 새로 엎었닀** — upstream 의 + 통곌 조걎읎 `"
" in line` 하나뿐읞데 `·` 는 슀플너읎멎서 **평범한 불늿**읎닀. Claude 의 + 답변 볞묞 `· 첫짞 항목은 ` 읎 상태쀄읎 되고, #98 읎 ê·ž 값윌로 타읎핑을 쌜므로 유휎 섞션에 + 유령 상태 메시지 + 영구 타읎핑읎 낚는닀. 비읞접 쀄은 `
` **귞늬고** `·` 가 아닐 것을 요구한닀. + ⚠ 구분선 **바로 위** 불늿은 main 에도 있던 êž°ì¡Ž 였탐읎띌 손대지 않았닀(싀잡 대조 확읞) +- **퍌믞션 프롬프튞가 떠 있는 낮낮 "작업 쀑" 윌로 볎읎던 것** — #98 의 `set_typing` 읎 + `update_status_message` 맚 끝에 한 번뿐읞데 ê·ž 위에 ì¡°êž° `return` 읎 셋읎닀. 프롬프튞는 + 사람읎 답할 때까지 몇 시간도 떠 있고, 싀제로는 뎇읎 **사용자륌 Ʞ닀늬는 쀑**읎닀. + ì„ž 지점에서 타읎핑을 끈닀(큐가 ì°¬ `skip_status` 는 제왞 — 에읎전튞가 싀제로 작업 쀑읎닀) +- **secondary 태슀크의 읎믞지가 고아로 낹던 것** — #94 가 몚윌는 id 에 `_send_task_images` + 가 볎낞 사진읎 ë¹ ì ž 있었닀. `tool_result` 는 항상 secondary 띌, 닀음 메시지가 였멎 + **섀명 텍슀튞만 지워지고 슀크늰샷읎 맥띜 없읎 낚는닀.** `send_photo` 가 message id 륌 + 반환하게 하고 전송을 추적볎닀 뚌저 한닀 +- **윜백 응답읎 최대 45쎈 지연되던 것** — `_create_and_bind_window` 가 `query.answer()` 륌 + 핚수 맚 끝에서 불렀는데, ê·ž 앞에 `wait_for_claude_ready`(30쎈) + `wait_for_session_map_entry` + (5~15쎈)가 있닀. 텔레귞랚은 ì•œ 15쎈륌 넘Ʞ멎 `query is too old` 륌 ë‚Žê³ , ê·ž 혞출엔 + try/except 가 없얎 귞대로 터진닀. 응답을 **맚 앞**윌로 옮게닀(결곌 ✅/❌ 는 `safe_edit` 가 + 메시지 볞묞윌로 볎여죌므로 잃는 정볎가 없닀) +- **`TOPIC_CHECK_INTERVAL` docstring 읎 60쎈로 ë‚šì•„ 있던 것** — #81 읎 5쎈로 낮췄닀. + ⚠ 바읞딩 1개당 API 혞출읎 12배가 되얎 #52 의 슀로틀곌 방향읎 반대닀. **레읎튞 늬밋을 + 싀제로 맞은 ꎀ잡읎 없얎** upstream 값을 유지하되, 귌거와 되돌늬는 값(15~20쎈)을 죌석에 낚게닀 + ### 검슝 -- `pytest` **432항 통곌** (뚞지 전 400항 → upstream 테슀튞 32항 추가) +- `pytest` **440항 통곌** (뚞지 전 400 → upstream 테슀튞 32 + 읎 fork 의 회귀 8) - `pyright src/ccbot/` **0 errors** -- `ruff check src/ tests/` 위반 **103 → 101** (슝가 없음. 낚은 것은 main 에도 있던 êž°ì¡Ž 부채) +- `ruff check src/ tests/` 위반 **103 → 102**. 파음·규칙 닚위로 대조핎 **main 에 없던 조합은 0걎**읎고, + 유음한 슝가는 `bot.py` BLE001 12 → 15(#81 `/kill` 핞듀러 + #99 슀윔프 헬퍌 2개)로 ê·ž 파음의 êž°ì¡Ž 슀타음곌 같닀 --- diff --git a/src/ccbot/bot.py b/src/ccbot/bot.py index e68170d07..487001f57 100644 --- a/src/ccbot/bot.py +++ b/src/ccbot/bot.py @@ -1299,6 +1299,15 @@ async def _create_and_bind_window( assert isinstance(query, CallbackQuery) assert isinstance(user, User) + # 🚚 윜백 응답을 **뚌저** 볎낞닀. 텔레귞랚은 answerCallbackQuery 륌 ì•œ 15쎈 안에 + # 받아알 하고, 넘Ʞ멎 "query is too old and response timeout expired" 륌 ë‚žë‹€. + # 아래 겜로는 wait_for_claude_ready(최대 30쎈) + wait_for_session_map_entry + # (5~15쎈) 륌 거치므로 최악 45쎈닀 — 예전엔 ê·ž 뒀에 응답핎서, ì°œ 하나가 느늬멎 + # 예왞가 나고 귞동안 사용자 버튌은 계속 로딩 상태였닀. + # 결곌(✅/❌)는 아래 safe_edit 가 메시지 볞묞윌로 볎여죌므로 잃는 정볎가 없닀. + # answerCallbackQuery 는 쿌늬당 1회띌 핚수 끝의 두 번짞 혞출은 없앎닀. + await query.answer("Creating
") + if config.auto_trust_dirs: await asyncio.to_thread(ensure_trusted_directory, selected_path) @@ -1418,7 +1427,6 @@ async def _create_and_bind_window( if pending_thread_id is not None and context.user_data is not None: context.user_data.pop("_pending_thread_id", None) context.user_data.pop("_pending_thread_text", None) - await query.answer("Created" if success else "Failed") # --- Callback query handler --- diff --git a/src/ccbot/handlers/message_queue.py b/src/ccbot/handlers/message_queue.py index 700ff184c..5031b90c6 100644 --- a/src/ccbot/handlers/message_queue.py +++ b/src/ccbot/handlers/message_queue.py @@ -377,16 +377,16 @@ def _send_kwargs(thread_id: int | None) -> dict[str, Any]: return {} -async def _send_task_images(bot: Bot, chat_id: int, task: MessageTask) -> None: - """Send images attached to a task, if any.""" +async def _send_task_images(bot: Bot, chat_id: int, task: MessageTask) -> list[int]: + """Send images attached to a task, if any. Returns their message ids.""" if not task.image_data: - return + return [] logger.info( "Sending %d image(s) in thread %s", len(task.image_data), task.thread_id, ) - await send_photo( + return await send_photo( bot, chat_id, task.image_data, @@ -544,12 +544,16 @@ async def _process_content_task(bot: Bot, user_id: int, task: MessageTask) -> No # task (several secondary entries queued together, folded into one # MessageTask by _merge_content_tasks) or a paginated local_command # can produce more than one Telegram message here. + # 6. Send images if present (from tool_result with base64 image blocks) + # 🚚 읎믞지륌 **뚌저 볎낎고** ê·ž id 까지 핚께 추적한닀. 예전 순서(추적 → 전송)에서는 + # 사진 id 가 목록에 안 듀얎가, 닀음 메시지가 였멎 **섀명 텍슀튞만 지워지고 + # 슀크늰샷읎 맥띜 없읎 낚았닀.** tool_result 는 항상 is_secondary=True 띌 + # 슀크늰샷을 찍는 섞션에서 맀번 재현된닀. + sent_msg_ids.extend(await _send_task_images(bot, chat_id, task)) + if sent_msg_ids and task.is_secondary: _secondary_msg_info[skey] = (sent_msg_ids, wid) - # 6. Send images if present (from tool_result with base64 image blocks) - await _send_task_images(bot, chat_id, task) - # Status display is delegated to status_polling (1s interval) so the answer # always remains the last visible message until polling detects working state. # 🔎 upstream 은 여Ʞ서 _check_and_send_status 륌 읞띌읞 혞출한닀(#94 도 ê·ž 자늬륌 diff --git a/src/ccbot/handlers/message_sender.py b/src/ccbot/handlers/message_sender.py index 886dd5fab..8e21f8e16 100644 --- a/src/ccbot/handlers/message_sender.py +++ b/src/ccbot/handlers/message_sender.py @@ -73,8 +73,17 @@ async def _maybe_cleanup_dead_topic( if thread_id is None: return from ..session import session_manager # lazy: avoid circular import - - await session_manager.cleanup_dead_topic(int(chat_id), int(thread_id)) + from .cleanup import clear_topic_state # lazy: avoid circular import + + # 🚚 ì„žì…˜ 상태만 푾는 것윌로 끝나지 않는닀. 핞듀러 쪜 토픜별 추적(상태 메시지 · + # tool id · secondary id · **타읎핑 keepalive 태슀크**)은 여Ʞ서 안 지우멎 귞대로 + # ë‚šê³ , _typing_keepalive 는 while True 띌 췚소 전엔 죜지 않는닀 — 텔레귞랚읎 + # "ê·ž 토픜 없닀" ê³  답한 thread 로 4쎈마닀 send_chat_action 을 영원히 던지게 된닀. + # 닀륞 ì„ž í•Žì œ 겜로(status_polling 2ê³³ · /kill · topic_closed)는 전부 부륞닀. + for user_id, t_id in await session_manager.cleanup_dead_topic( + int(chat_id), int(thread_id) + ): + await clear_topic_state(user_id, t_id) async def send_with_fallback( @@ -128,11 +137,16 @@ async def send_photo( chat_id: int, image_data: list[tuple[str, bytes]], **kwargs: Any, -) -> None: +) -> list[int]: """Send photo(s) to chat. Sends as media group if multiple images. Rate limiting is handled globally by AIORateLimiter on the Application. + Returns the message ids actually sent (empty on failure) so callers can + track them — a tool_result's screenshot belongs to the same "secondary" + message group as its text, and an untracked photo outlives the text that + explained it. + Args: bot: Telegram Bot instance chat_id: Target chat ID @@ -140,29 +154,31 @@ async def send_photo( **kwargs: Extra kwargs passed to send_photo/send_media_group """ if not image_data: - return + return [] try: if len(image_data) == 1: _media_type, raw_bytes = image_data[0] - await bot.send_photo( + sent = await bot.send_photo( chat_id=chat_id, photo=io.BytesIO(raw_bytes), **kwargs, ) - else: - media = [ - InputMediaPhoto(media=io.BytesIO(raw_bytes)) - for _media_type, raw_bytes in image_data - ] - await bot.send_media_group( - chat_id=chat_id, - media=media, - **kwargs, - ) + return [sent.message_id] + media = [ + InputMediaPhoto(media=io.BytesIO(raw_bytes)) + for _media_type, raw_bytes in image_data + ] + msgs = await bot.send_media_group( + chat_id=chat_id, + media=media, + **kwargs, + ) + return [m.message_id for m in msgs] except RetryAfter: raise except Exception as e: logger.error("Failed to send photo to %d: %s", chat_id, e) + return [] async def safe_reply(message: Message, text: str, **kwargs: Any) -> Message: diff --git a/src/ccbot/handlers/status_polling.py b/src/ccbot/handlers/status_polling.py index a359d7be5..61243539b 100644 --- a/src/ccbot/handlers/status_polling.py +++ b/src/ccbot/handlers/status_polling.py @@ -12,7 +12,7 @@ Key components: - STATUS_POLL_INTERVAL: Polling frequency (1 second) - - TOPIC_CHECK_INTERVAL: Topic existence probe frequency (60 seconds) + - TOPIC_CHECK_INTERVAL: Topic existence probe frequency (5 seconds) - status_poll_loop: Background polling task - update_status_message: Poll and enqueue status updates - _should_send_status: Adaptive throttle for timer status updates @@ -50,7 +50,15 @@ # Timer-based status updates are throttled adaptively by _should_send_status(). STATUS_POLL_INTERVAL = 1.0 # seconds -# Topic existence probe interval +# Topic existence probe interval. +# ⚠ upstream #81 읎 60쎈 → 5쎈로 낮췄닀. 목적은 DM 몚드에서 삭제된 토픜을 빚늬 잡는 +# 것읞데(private chat 은 unpinAllForumTopicMessages 가 아묎 thread_id 에나 ok=true 륌 +# 쀀닀), 바읞딩 1개당 API 혞출읎 **12ë°°**가 된닀 — 토픜 6개멎 분당 72회닀. +# 같은 람랜치의 #52 가 "레읎튞 늬밋 때묞에 뎇읎 장시간 칚묵한닀" ë©° 상태 업데읎튞륌 +# 슀로틀하는 것곌 방향읎 반대띌 서로 상쇄될 수 있닀. +# 지ꞈ은 upstream 값을 귞대로 둔닀 — **레읎튞 늬밋을 싀제로 맞은 ꎀ잡읎 없닀.** +# 맞윌멎 여Ʞ륌 15~20쎈로 올늰닀(죜은 토픜은 전송 싀팚 겜로의 +# _maybe_cleanup_dead_topic 읎 읎믞 슉시 잡윌므로 읎 프로람는 백슀톱읎닀). TOPIC_CHECK_INTERVAL = 5.0 # seconds # Substrings in BadRequest messages that indicate the topic is gone @@ -175,6 +183,11 @@ async def update_status_message( # User is in interactive mode for THIS window if is_interactive_ui(pane_text): # Interactive UI still showing — skip status update (user is interacting) + # 🚚 타읎핑은 반드시 끈닀. 여Ʞ서 빠젞나가멎 아래 set_typing 에 닿지 못핎, + # 직전 폎링에서 쌜진 표시가 4쎈마닀 계속 나간닀. 퍌믞션 프롬프튞는 + # 사람읎 답할 때까지 몇 시간도 떠 있고, ê·ž 낮낮 "작업 쀑" 윌로 볎읞닀. + # 싀제로는 뎇읎 **사용자륌 Ʞ닀늬는 쀑**읎닀. + set_typing(bot, user_id, thread_id, False) return # Interactive UI gone — clear interactive mode, fall through to status check. # Don't re-check for new UI this cycle (the old one just disappeared). @@ -191,6 +204,7 @@ async def update_status_message( ui = extract_interactive_content(pane_text) if ui is not None and ui.name in AUTO_ANSWER_DIALOGS: await tmux_manager.auto_answer_dialog(window_id, pane_text) + set_typing(bot, user_id, thread_id, False) # 위와 같은 읎유 return # Check for permission prompt (interactive UI not triggered via JSONL) @@ -203,9 +217,12 @@ async def update_status_message( thread_id, ) await handle_interactive_ui(bot, user_id, window_id, thread_id) + set_typing(bot, user_id, thread_id, False) # 위와 같은 읎유 return # Normal status line check — skip if queue is non-empty + # 🔎 여Ʞ는 타읎핑을 끄지 않는닀 — 큐가 ì°¬ 음시적 상태읎고, 에읎전튞는 싀제로 + # 작업 쀑읎닀. 껐닀 쌜멎 표시가 깜빡읞닀. if skip_status: return diff --git a/src/ccbot/session.py b/src/ccbot/session.py index c7d147da8..7f3ec531c 100644 --- a/src/ccbot/session.py +++ b/src/ccbot/session.py @@ -977,16 +977,27 @@ def purge_window(self, window_id: str) -> None: self._save_state() logger.info("Purged window state for %s", window_id) - async def cleanup_dead_topic(self, chat_id: int, thread_id: int) -> bool: + async def cleanup_dead_topic( + self, chat_id: int, thread_id: int + ) -> list[tuple[int, int]]: """Tear down any binding whose chat_id+thread_id matches a dead topic. Called from send-failure paths when Telegram returns "Message thread not - found" / "Topic_id_invalid". The 60s topic-existence probe can miss this - in private chats (Telegram returns ok=true for unpinAllForumTopicMessages - on private chats with arbitrary thread_ids). Returns True if any binding - was cleaned up. + found" / "Topic_id_invalid". The topic-existence probe can miss this in + private chats (Telegram returns ok=true for unpinAllForumTopicMessages + on private chats with arbitrary thread_ids). + + 🚚 Returns the (user_id, thread_id) pairs it cleaned so the caller can + run clear_topic_state() on each. This method only unwinds *session* + state; the per-topic in-memory trackers in handlers/ (status message, + tool ids, secondary message ids, and the typing keepalive task) live + elsewhere and would otherwise survive. A surviving typing task is not a + harmless leak: _typing_keepalive loops forever, so the bot would keep + firing send_chat_action every 4s at a thread Telegram already told us is + gone. Upstream (#81) returned a bare bool and left that behind; the + other three unbind paths all call clear_topic_state. """ - cleaned = False + cleaned: list[tuple[int, int]] = [] for user_id, t_id, wid in list(self.iter_thread_bindings()): if t_id != thread_id: continue @@ -995,7 +1006,7 @@ async def cleanup_dead_topic(self, chat_id: int, thread_id: int) -> bool: self.unbind_thread(user_id, t_id) self.purge_window(wid) await self.remove_session_map_entry(wid) - cleaned = True + cleaned.append((user_id, t_id)) logger.info( "Auto-cleaned dead topic via send error: " "user=%d thread=%d window_id=%s", diff --git a/src/ccbot/terminal_parser.py b/src/ccbot/terminal_parser.py index a0067b00a..4bc5feae9 100644 --- a/src/ccbot/terminal_parser.py +++ b/src/ccbot/terminal_parser.py @@ -349,9 +349,11 @@ def parse_status_line(pane_text: str) -> str | None: separator (a full line of ``─`` characters). We locate the separator first, then scan upward. The line *directly* above it counts as a status line on the spinner alone; further up, Claude Code may have rendered a tip - block in between, so a spinner line only counts when it also carries the - ``
`` of a live status — that keeps ``·`` bullets in regular output and the - finished marker (``✻ Sautéed for 7s``) from being mistaken for status. + block in between, so a spinner line only counts when it carries the ``
`` + of a live status **and** is not a plain ``·`` bullet. That pair of + conditions applies to non-adjacent lines only — directly above the + separator, ``✻ Sautéed for 7s`` is still returned as status (unchanged + behaviour). Returns the text after the spinner, or None if no status line found. @@ -380,16 +382,27 @@ def parse_status_line(pane_text: str) -> str | None: # Scan upward for the spinner line. Claude Code can render a tip block # between the status line and the chrome, so keep looking past non-spinner - # lines — but once we're past the line directly above the separator, only a - # live status line counts. The ellipsis is what marks one, and it keeps - # prose bullets and the finished marker ("✻ Sautéed for 7s") out. - # (upstream six-ddc/ccbot#97) + # lines (upstream six-ddc/ccbot#97). + # + # 🚚 Past the line directly above the separator the bar is higher, because + # prose lives up there. Two conditions, and both are needed: + # - "
" — the finished marker ("✻ Sautéed for 7s") has no ellipsis + # - not "·" — this is the one spinner glyph that is also an ordinary + # bullet. Claude's own answers are full of "· item one
" lines, and + # upstream's ellipsis-only rule let them through: a bullet three + # lines above the separator became the status text. That misfire is + # not cosmetic — status_polling lights the typing keepalive off this + # return value, so a stray bullet in an idle pane leaves a ghost + # status message and a typing indicator that never turns off. + # tests/ccbot/test_terminal_parser.py has guarded this since before + # the merge ("· in regular output must NOT be detected as status"). adjacent = True for i in range(chrome_idx - 1, max(chrome_idx - 9, -1), -1): line = lines[i].strip() if not line: continue - if line[0] in STATUS_SPINNERS and (adjacent or "
" in line): + live = "
" in line and line[0] != "·" + if line[0] in STATUS_SPINNERS and (adjacent or live): rest = line[1:].strip() if ( _BACKGROUND_SHELL_RE.search(rest) diff --git a/tests/ccbot/test_upstream_merge_fixes.py b/tests/ccbot/test_upstream_merge_fixes.py new file mode 100644 index 000000000..7386bfbed --- /dev/null +++ b/tests/ccbot/test_upstream_merge_fixes.py @@ -0,0 +1,184 @@ +"""upstream 컀뮀니티 PR 9걎을 읎 fork 에 합치멎서 **새로 생ꞎ ê²°í•š**을 고정한닀. + +2026-09-16 뚞지 늬뷰가 잡은 것듀읎닀. 전부 "upstream 팚치는 맞는데 읎 fork 의 닀륞 +부분곌 겹쳐서 깚지는" 형태띌, upstream 테슀튞로는 잡히지 않는닀. + + 1. #81 의 cleanup_dead_topic 읎 ì„žì…˜ 상태만 풀고 핞듀러 쪜 토픜 추적을 낚ꞎ닀. + #98 읎 붙윌멎서 읎게 닚순 누수가 아니띌 **묎한 API 혞출**읎 됐닀 — + _typing_keepalive 는 while True 띌, 텔레귞랚읎 "ê·ž 토픜 없닀" ê³  답한 thread 로 + 4쎈마닀 send_chat_action 을 영원히 던진닀. + 2. #97 의 8쀄 위 슀캔읎 `·` 불늿을 상태쀄로 읜는 구멍을 **비읞접 쀄에** 새로 엎었닀. + #98 곌 겹치멎 유휎 섞션에 타읎핑 표시가 영구히 쌜진닀. + (구분선 **바로 위** 불늿은 main 에도 있던 êž°ì¡Ž 였탐읎띌 읎 테슀튞의 범위가 아니닀) + 3. #98 의 set_typing 읎 update_status_message 맚 끝에 한 번뿐읞데 ê·ž 위에 ì¡°êž° + return 읎 ì„ž 개닀 — 퍌믞션 프롬프튞가 떠 있는 낮낮 "작업 쀑" 윌로 볎읞닀. + 4. #94 가 secondary 메시지 id 륌 몚윌는데 **읎믞지 id 는 ë¹ ì ž** 있었닀. + 섀명 텍슀튞만 지워지고 슀크늰샷읎 맥띜 없읎 낚는닀. +""" + +from unittest.mock import AsyncMock, MagicMock, patch + +import pytest + +from ccbot.handlers.message_queue import ( + MessageTask, + _process_content_task, + _secondary_msg_info, + _tool_msg_ids, + _typing_tasks, + set_typing, +) +from ccbot.terminal_parser import parse_status_line + +USER_ID = 7 +THREAD_ID = 42 +CHAT_ID = 555 +CHROME = "─" * 40 + + +@pytest.fixture(autouse=True) +def _clear_state(): + for d in (_secondary_msg_info, _tool_msg_ids): + d.clear() + for t in list(_typing_tasks.values()): + t.cancel() + _typing_tasks.clear() + yield + for t in list(_typing_tasks.values()): + t.cancel() + _typing_tasks.clear() + for d in (_secondary_msg_info, _tool_msg_ids): + d.clear() + + +# ── 1. 죜은 토픜을 정늬하멎 타읎핑 태슀크도 같읎 죜얎알 한닀 ────────────────── +@pytest.mark.asyncio +class TestDeadTopicClearsHandlerState: + async def test_cleanup_cancels_typing_task(self) -> None: + """읎게 안 되멎 뎇읎 없는 토픜에 4쎈마닀 chat action 을 영원히 던진닀.""" + from ccbot.handlers.message_sender import _maybe_cleanup_dead_topic + + bot = AsyncMock() + with patch("ccbot.handlers.message_queue.session_manager") as mock_sm: + mock_sm.resolve_chat_id.return_value = CHAT_ID + set_typing(bot, USER_ID, THREAD_ID, True) + assert (USER_ID, THREAD_ID) in _typing_tasks + + with patch("ccbot.session.session_manager") as sess: + sess.cleanup_dead_topic = AsyncMock( + return_value=[(USER_ID, THREAD_ID)] + ) + await _maybe_cleanup_dead_topic( + CHAT_ID, + {"message_thread_id": THREAD_ID}, + Exception("Message thread not found"), + ) + + assert (USER_ID, THREAD_ID) not in _typing_tasks, ( + "죜은 토픜을 정늬했는데 타읎핑 keepalive 가 삎아낚았닀" + ) + + async def test_unrelated_error_does_not_clean(self) -> None: + """TimedOut 윌로 토픜을 지우멎 넀튞워크가 흔듀늎 때마닀 바읞딩읎 ë‚ ì•„ê°„ë‹€.""" + from ccbot.handlers.message_sender import _maybe_cleanup_dead_topic + + with patch("ccbot.session.session_manager") as sess: + sess.cleanup_dead_topic = AsyncMock(return_value=[]) + await _maybe_cleanup_dead_topic( + CHAT_ID, {"message_thread_id": THREAD_ID}, Exception("Timed out") + ) + sess.cleanup_dead_topic.assert_not_called() + + +# ── 2. 비읞접 `·` 불늿은 상태쀄읎 아니닀 ───────────────────────────────────── +class TestBulletIsNotStatus: + def test_bullet_three_lines_above_is_not_status(self) -> None: + pane = f"· 첫짞 항목은 읎렇고 \n결곌 쀄\n또 한 쀄\n{CHROME}" + assert parse_status_line(pane) is None + + def test_tip_block_case_still_works(self) -> None: + """#97 읎 고치렀던 것 — 읎 쌀읎슀가 죜윌멎 수정읎 곌했닀는 뜻읎닀.""" + pane = f"출력\n✳ Gitifying
 (2m 1s)\n ⎿ Tip: 얎쩌고\n\n{CHROME}" + assert parse_status_line(pane) == "Gitifying
 (2m 1s)" + + def test_finished_marker_non_adjacent_is_not_status(self) -> None: + pane = f"출력\n✻ Sautéed for 7s\n결곌 쀄\n{CHROME}" + assert parse_status_line(pane) is None + + def test_background_shell_filter_survives_non_adjacent(self) -> None: + """fork 고유 필터 — upstream 팚치가 읎걞 묎력화하지 않았는지.""" + pane = ( + f"출력\n✻ Running
 (3s · 1 shell still running)\n ⎿ Tip: x\n{CHROME}" + ) + assert parse_status_line(pane) is None + + +# ── 3. 읞터랙티람 UI 가 떠 있윌멎 타읎핑을 끈닀 ────────────────────────────── +@pytest.mark.asyncio +class TestTypingOffWhileWaitingForUser: + async def test_interactive_ui_turns_typing_off(self) -> None: + from ccbot.handlers import status_polling + + bot = AsyncMock() + with patch("ccbot.handlers.message_queue.session_manager") as mock_sm: + mock_sm.resolve_chat_id.return_value = CHAT_ID + set_typing(bot, USER_ID, THREAD_ID, True) + assert (USER_ID, THREAD_ID) in _typing_tasks + + with ( + patch.object(status_polling, "get_interactive_window", return_value="@1"), + patch.object(status_polling, "is_interactive_ui", return_value=True), + patch.object(status_polling, "session_manager") as sp_sm, + patch.object(status_polling, "tmux_manager") as sp_tmux, + patch.object(status_polling, "get_message_queue") as gq, + ): + sp_sm.resolve_chat_id.return_value = CHAT_ID + win = MagicMock() + win.window_id = "@1" + sp_tmux.find_window_by_id = AsyncMock(return_value=win) + sp_tmux.capture_pane = AsyncMock(return_value="퍌믞션 프롬프튞") + gq.return_value = MagicMock(empty=MagicMock(return_value=True)) + await status_polling.update_status_message( + bot, USER_ID, "@1", thread_id=THREAD_ID + ) + + assert (USER_ID, THREAD_ID) not in _typing_tasks, ( + "사용자 답을 Ʞ닀늬는 동안 '작업 쀑' 표시가 계속 나간닀" + ) + + +# ── 4. secondary 태슀크의 읎믞지도 같읎 지워진닀 ───────────────────────────── +@pytest.mark.asyncio +class TestSecondaryImagesTracked: + async def test_image_ids_are_tracked_with_text(self) -> None: + bot = AsyncMock() + text_msg = MagicMock() + text_msg.message_id = 100 + bot.send_message.return_value = text_msg + photo_msg = MagicMock() + photo_msg.message_id = 101 + bot.send_photo.return_value = photo_msg + + task = MessageTask( + task_type="content", + window_id="@1", + parts=["슀크늰샷 찍었습니닀"], + content_type="tool_result", + thread_id=THREAD_ID, + is_secondary=True, + image_data=[("image/png", b"fake")], + ) + + with ( + patch("ccbot.handlers.message_queue.session_manager") as mock_sm, + patch("ccbot.handlers.message_queue.tmux_manager") as mock_tmux, + ): + mock_sm.resolve_chat_id.return_value = CHAT_ID + mock_tmux.find_window_by_id = AsyncMock(return_value=None) + await _process_content_task(bot, USER_ID, task) + + ids, _wid = _secondary_msg_info[(USER_ID, THREAD_ID)] + assert 101 in ids, ( + "사진 id 가 추적에서 빠지멎 섀명 텍슀튞만 지워지고 슀크늰샷읎 고아로 낚는닀" + ) + assert ids == [100, 101]