fix: address review on #176 — edit parse_mode regression, feed file mode and location

- edit_message: only forward parse_mode when the caller set it. Telethon
  treats an explicit None as "disable parsing" while an omitted argument
  uses its default parser, so passing None unconditionally turned
  previously formatted edits (**bold**) into literal text.
- Feed file is now opened via os.open(O_CREAT|O_APPEND, 0o600) with an
  fchmod fallback, so an existing or externally rotated 0644 file is
  tightened too — Path.touch(mode=...) only applies its mode on creation.
- Feed default path no longer derives from __file__ (unwritable under a
  read-only site-packages or container layer): it follows XDG state
  (${XDG_STATE_HOME:-~/.local/state}/telegram-mcp/incoming_feed.jsonl) and
  creates that directory. An explicit TELEGRAM_EVENT_FEED_FILE still must
  point at an existing directory so typos fail loudly.

Tests: 6 new (default location, dir creation, 0600 on create/existing/
rotated, parse_mode forwarding); suite 200 passed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ex3lite

README.md

@@ -60,7 +60,7 @@ By default, an agent waits for replies by calling `wait_for_settled_message`, wh
 
 Clients that can wake an agent on external output (Claude Code's persistent `Monitor` on `tail -f`) can switch to callback mode instead:
 
-1. The agent calls `enable_incoming_feed` (or set `TELEGRAM_EVENT_FEED=1` in the environment to auto-enable). Each settled incoming burst is appended as one JSON line to `incoming_feed.jsonl` (path configurable via `TELEGRAM_EVENT_FEED_FILE`).
+1. The agent calls `enable_incoming_feed` (or set `TELEGRAM_EVENT_FEED=1` in the environment to auto-enable). Each settled incoming burst is appended as one JSON line to `${XDG_STATE_HOME:-~/.local/state}/telegram-mcp/incoming_feed.jsonl`, created owner-only (0600). Override the path with `TELEGRAM_EVENT_FEED_FILE` — an explicit path's directory must already exist. `incoming_feed_status` reports the effective path and a ready-to-use watch command.
 2. The agent arms a persistent Monitor with the `watch_command` returned by the tool. Every new line re-invokes the agent with the burst summary; no blocking tool call is held open, and the chat stays free.
 
 `disable_incoming_feed` switches back; `incoming_feed_status` reports the current mode. While the feed is enabled it consumes settled bursts, so don't combine it with `wait_for_settled_message`. Feed lines contain user-generated `name` fields — treat them as untrusted data.

telegram_mcp/tools/events.py

@@ -10,6 +10,7 @@
 import json
 import os
 import shlex
+import stat
 import time
 import logging
 from pathlib import Path
@@ -29,7 +30,7 @@
 # JSONL lines to the feed file, so an external watcher (e.g. Claude Code's
 # Monitor on `tail -f`) can wake an agent per event instead of the agent
 # holding a blocking wait_for_settled_message call open.
-_FEED_DEFAULT = Path(__file__).resolve().parent.parent.parent / "incoming_feed.jsonl"
+_FEED_FILE_ENV = "TELEGRAM_EVENT_FEED_FILE"
 _feed_task: Optional[asyncio.Task] = None
 _feed_settle_ms: int = 6000
 _feed_autostart_done: bool = False
@@ -75,17 +76,50 @@ def _burst_summary(chat_id: int, rec: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
+def _default_feed_file() -> Path:
+    """Runtime data location, never the install directory.
+
+    The package may live in a read-only site-packages or container layer, so the
+    default feed path follows the XDG state convention instead of `__file__`.
+    """
+    base = os.getenv("XDG_STATE_HOME") or Path.home() / ".local" / "state"
+    return Path(base) / "telegram-mcp" / "incoming_feed.jsonl"
+
+
 def feed_file_path() -> Path:
-    return Path(os.getenv("TELEGRAM_EVENT_FEED_FILE", str(_FEED_DEFAULT)))
+    override = os.getenv(_FEED_FILE_ENV)
+    return Path(override) if override else _default_feed_file()
 
 
 def feed_enabled() -> bool:
     return _feed_task is not None and not _feed_task.done()
 
 
+def _open_feed_append():
+    """Append-open the feed file, enforcing 0600 — it holds private contact metadata.
+
+    `Path.touch(mode=...)` only applies its mode when creating, so an existing or
+    externally rotated 0644 file keeps its permissions; fchmod on the open
+    descriptor fixes that without a TOCTOU window.
+    """
+    path = feed_file_path()
+    if not os.getenv(_FEED_FILE_ENV):
+        # Only auto-create the directory we own; an explicit path must exist so a
+        # typo fails loudly instead of scattering directories.
+        path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
+    try:
+        if stat.S_IMODE(os.fstat(fd).st_mode) != 0o600:
+            os.fchmod(fd, 0o600)
+    except OSError:
+        os.close(fd)
+        raise
+    return os.fdopen(fd, "a", encoding="utf-8")
+
+
 def _touch_feed_file() -> None:
-    """Create the feed file owner-only (0600) if missing; contact metadata is private."""
-    feed_file_path().touch(mode=0o600, exist_ok=True)
+    """Create (or fix the mode of) the feed file before starting the consumer."""
+    _open_feed_append().close()
 
 
 async def _feed_loop(settle_ms: int) -> None:
@@ -100,7 +134,7 @@ async def _feed_loop(settle_ms: int) -> None:
                 line = dict(_burst_summary(settled_cid, rec), ts=round(time.time(), 2))
                 del line["event"]
                 # ponytail: append-only file; rotate it manually (tail -F survives rotation)
-                with open(feed_file_path(), "a", encoding="utf-8") as f:
+                with _open_feed_append() as f:
                     f.write(json.dumps(line, ensure_ascii=False) + "\n")
                 # Pop only after a successful write (no await in between, so no
                 # consumer can observe the burst twice); a write failure retries

telegram_mcp/tools/messages.py

@@ -1144,13 +1144,20 @@ async def edit_message(
             'html', or 'rich'/'rich_markdown'/'rich_html' for full server-side formatting
             (tables, headings, formulas; REQUIRES Telegram Premium — without it nothing is
             changed and a structured telegram_premium_required result is returned).
+            Omitting it keeps the previous behavior of this tool: Telethon's client
+            default (Markdown), so **bold** in existing edits still renders.
     """
     try:
         cl = get_client(account)
         entity = await resolve_entity(chat_id, cl)
         if parse_mode and parse_mode.lower() in RICH_PARSE_MODES:
             return await _edit_rich(cl, entity, message_id, new_text, parse_mode.lower())
-        await cl.edit_message(entity, message_id, new_text, parse_mode=parse_mode)
+        # Only pass parse_mode when the caller set it: Telethon treats an explicit
+        # None as "disable parsing", while omitting the argument uses its default
+        # parser. Passing None unconditionally would turn previously formatted
+        # edits into literal text.
+        extra = {"parse_mode": parse_mode} if parse_mode is not None else {}
+        await cl.edit_message(entity, message_id, new_text, **extra)
         return f"Message {message_id} edited."
     except Exception as e:
         return log_and_format_error(

tests/test_event_feed.py

@@ -2,7 +2,10 @@
 
 import asyncio
 import json
+import os
+import stat
 import time
+from pathlib import Path
 
 import pytest
 
@@ -172,6 +175,58 @@ async def test_write_failure_retains_burst(monkeypatch, tmp_path):
     assert 42 in events._pending_msgs  # not silently destroyed
 
 
+def test_default_feed_path_is_runtime_state_not_install_dir(monkeypatch, tmp_path):
+    monkeypatch.delenv("TELEGRAM_EVENT_FEED_FILE", raising=False)
+    monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path))
+
+    path = events.feed_file_path()
+
+    assert path == tmp_path / "telegram-mcp" / "incoming_feed.jsonl"
+    assert Path(events.__file__).parent not in path.parents
+
+
+def test_default_feed_path_creates_its_directory(monkeypatch, tmp_path):
+    monkeypatch.delenv("TELEGRAM_EVENT_FEED_FILE", raising=False)
+    monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path / "fresh"))
+
+    events._touch_feed_file()
+
+    assert events.feed_file_path().exists()
+
+
+def test_feed_file_created_owner_only():
+    events._touch_feed_file()
+    mode = stat.S_IMODE(events.feed_file_path().stat().st_mode)
+    assert mode == 0o600
+
+
+def test_existing_world_readable_feed_file_is_tightened():
+    path = events.feed_file_path()
+    path.touch()
+    os.chmod(path, 0o644)
+
+    events._touch_feed_file()
+
+    assert stat.S_IMODE(path.stat().st_mode) == 0o600
+
+
+@pytest.mark.asyncio
+async def test_rotated_world_readable_file_is_tightened_on_write():
+    path = events.feed_file_path()
+    path.touch()
+    os.chmod(path, 0o644)
+    events._pending_msgs[42] = _pending_record(_mono(1.0))
+    events._start_feed(settle_ms=50)
+
+    for _ in range(50):
+        await asyncio.sleep(0.02)
+        if not events._pending_msgs:
+            break
+
+    assert stat.S_IMODE(path.stat().st_mode) == 0o600
+    assert path.read_text(encoding="utf-8").strip()
+
+
 @pytest.mark.asyncio
 async def test_status_reports_autostart_pending(monkeypatch):
     monkeypatch.setenv("TELEGRAM_EVENT_FEED", "on")  # repo-style bool value

tests/test_rich_messages.py

@@ -75,6 +75,36 @@ async def test_send_rich_other_rpc_error_propagates():
         await messages._send_rich(cl, "peer", "x", "rich")
 
 
+class _EditRecorder:
+    """Records how edit_message forwards parse_mode to Telethon."""
+
+    def __init__(self):
+        self.calls = []
+
+    async def edit_message(self, entity, message_id, text, **kwargs):
+        self.calls.append(kwargs)
+
+
+@pytest.mark.asyncio
+async def test_edit_message_omits_parse_mode_when_not_given(monkeypatch):
+    # Telethon treats an explicit None as "disable parsing" while an omitted
+    # argument uses its default parser, so callers who never passed parse_mode
+    # must keep getting formatted edits.
+    cl = _EditRecorder()
+    monkeypatch.setattr(messages, "get_client", lambda account=None: cl)
+
+    async def fake_resolve(chat_id, client=None):
+        return "entity"
+
+    monkeypatch.setattr(messages, "resolve_entity", fake_resolve)
+
+    await messages.edit_message(chat_id=1, message_id=2, new_text="**bold**")
+    assert cl.calls == [{}]
+
+    await messages.edit_message(chat_id=1, message_id=2, new_text="x", parse_mode="html")
+    assert cl.calls[-1] == {"parse_mode": "html"}
+
+
 @pytest.mark.asyncio
 async def test_edit_rich_both_premium_cases():
     ok = _FakeClient(premium=True)