claude-telegram-mirror 0.2.23 → 0.2.25

package/README.md

@@ -137,20 +137,33 @@ Approval buttons only appear in normal mode, not with `--dangerously-skip-permis
 ## Architecture
 
 ```
-┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
-│   Claude Code   │────▶│   ctm daemon    │────▶│    Telegram     │
-│      CLI        │◀────│  (Rust binary)  │◀────│      Bot        │
-└─────────────────┘     └─────────────────┘     └─────────────────┘
-        │                       │
-        │ hooks                 │ Unix socket
-        ▼                       ▼
-┌─────────────────┐     ┌─────────────────┐
-│  ctm hook       │────▶│  Socket Server  │
-│  (same binary,  │◀────│  (bidirectional)│
-│   hook mode)    │     │                 │
-└─────────────────┘     └─────────────────┘
+OUTBOUND  (CLI → Telegram) — Claude Code mirrors all activity out:
+
+  ┌─────────────┐  fires   ┌──────────┐  NDJSON over  ┌──────────────┐  Bot API   ┌──────────────┐
+  │ Claude Code │  hook    │ ctm hook │  Unix socket  │  ctm daemon  │  sendMsg   │  Telegram    │
+  │ CLI (tmux)  │ ───────▶ │ (binary) │ ────────────▶ │ (event loop) │ ─────────▶ │ forum topic  │
+  └─────────────┘          └──────────┘               └──────────────┘            └──────────────┘
+
+INBOUND  (Telegram → CLI) — daemon injects into the live pane:
+
+  ┌─────────────┐  tmux send-keys  ┌──────────────┐  getUpdates long poll    ┌──────────────┐
+  │ Claude Code │ ◀─────────────── │  ctm daemon  │ ◀─────────────────────── │  Telegram    │
+  │ CLI (tmux)  │  -t <pane>       │ InputInjector│  text & button callbacks │  forum topic │
+  └─────────────┘                  └──────────────┘                          └──────────────┘
+
+  Approvals (PreToolUse): the hook blocks on the Unix socket for an approval_response;
+  the daemon shows inline buttons in Telegram and writes the verdict back to the hook.
+
+  ctm daemon = tokio event loop · Unix SocketServer · SessionManager (SQLite) + per-session tmux cache
+               · TelegramBot (Bot API) · InputInjector (tmux) · pending approval / question state
 ```
 
+> The `ctm hook` and the daemon are the **same binary** in different modes. Outbound rides
+> hook → Unix socket → daemon → Bot API; inbound rides daemon long-poll → `InputInjector`
+> (`tmux send-keys`) into the live CLI pane. The daemon resolves a session's tmux pane from
+> its cache then SQLite, and **fails closed** if that session never reported one (ROUTING-001) —
+> it never guesses a pane, to avoid misrouting keystrokes into another session.
+
 **Flow:**
 1. Claude Code hooks invoke `ctm hook`, which reads the event from stdin
 2. PreToolUse: for tool approvals, sends an approval request via socket and blocks for the Telegram response. **AskUserQuestion is *not* intercepted here** — the hook returns fast so Claude renders its native widget in the CLI; the daemon mirrors the question to Telegram from the standard `tool_start` event (ADR-015)
@@ -301,7 +314,7 @@ ctm install-hooks --project
 - **Topic routing**: Each daemon only processes topics it created (multi-bot safe)
 - **Rate limiting**: Governor-based with exponential backoff retry queue
 - **Token scrubbing**: All log output filtered through regex to strip bot tokens
-- **Test suite**: 512 Rust tests (unit + 10 integration test files)
+- **Test suite**: 470+ Rust tests (unit + 11 integration test files)
 
 ## Troubleshooting
 
@@ -367,7 +380,7 @@ cargo test
 ./target/release/ctm start
 ```
 
-### Project Structure (30 source files)
+### Project Structure (33 source files)
 
 ```
 rust-crates/ctm/src/
@@ -382,16 +395,19 @@ rust-crates/ctm/src/
   injector.rs       # tmux input injection
   formatting.rs     # Message formatting, chunking, ANSI stripping
   summarize.rs      # Tool action summarizer (30+ patterns)
+  liveness.rs       # tmux pane liveness checks for topic reconciliation
+  prune.rs          # prune-topics subcommand (bulk stale-topic cleanup)
   colors.rs         # ANSI color helpers for terminal output
   doctor.rs         # Diagnostic checks with --fix
   installer.rs      # Hook installer
   setup.rs          # Interactive setup wizard
-  bot/              # Telegram API client (client.rs, queue.rs, types.rs)
+  bot/              # Telegram API client (mod.rs, client.rs, queue.rs, types.rs)
   daemon/           # Bridge daemon (mod.rs, event_loop.rs, socket_handlers.rs,
-                    #   telegram_handlers.rs, callback_handlers.rs, cleanup.rs, files.rs)
+                    #   telegram_handlers.rs, callback_handlers.rs, cleanup.rs,
+                    #   reconcile.rs, files.rs)
   service/          # OS service management (mod.rs, systemd.rs, launchd.rs, env.rs)
 
-rust-crates/ctm/tests/   # 10 integration test files
+rust-crates/ctm/tests/   # 11 integration test files
 ```
 
 </details>

package/SECURITY.md

@@ -62,11 +62,11 @@ metacharacters are rejected.
 
 ### 2. Bot Token Scrubbing
 
-**File:** `rust-crates/ctm/src/bot/client.rs`
+**Files:** `rust-crates/ctm/src/main.rs` (subscriber layer), `rust-crates/ctm/src/bot/mod.rs` (regex)
 
-A `tracing` subscriber layer applies `scrub_bot_token()` to log output.
-The regex `bot\d+:[A-Za-z0-9_-]+/` matches the Telegram bot token pattern
-in API URLs and replaces it with `bot<REDACTED>`.
+A `tracing` subscriber layer (`ScrubWriter` in `main.rs`) applies `scrub_bot_token()`
+to all log output. The regex `bot\d+:[A-Za-z0-9_-]+/` matches the Telegram bot token
+pattern in API URLs and replaces it with `bot[REDACTED]/`.
 
 All log output goes to stderr via the `tracing` subscriber. There is no
 file transport, so tokens cannot leak into log files on disk.
@@ -79,8 +79,9 @@ tokens from error messages before logging.
 **File:** `rust-crates/ctm/src/daemon/telegram_handlers.rs`
 
 A chat ID check verifies `chat.id` against the configured `chat_id` on
-every incoming update. Updates from unauthorized chats receive a static
-"Unauthorized" reply and are not processed further.
+every incoming update. Updates from unauthorized chats are silently dropped
+(logged as a warning, no reply) — by design, since replying would confirm the
+bot's existence and function to an attacker (ADR-006 L4.6).
 
 Approval callback handlers (`approve:`, `reject:`, `abort:`), answer
 handlers (`answer:`, `toggle:`, `submit:`), all verify the chat ID
@@ -94,7 +95,7 @@ different chat.
 
 Session IDs from hook events are validated before any database operation:
 - Maximum length: 128 characters
-- Character set: `[a-zA-Z0-9_-]` only
+- Character set: `[a-zA-Z0-9_.-]` only
 - Empty/null values are rejected
 
 Messages with invalid session IDs are dropped with a warning log.
@@ -118,10 +119,10 @@ socket.
 
 **File:** `rust-crates/ctm/src/config.rs`
 
-`validateSocketPath()` rejects socket paths that:
+`validate_socket_path()` rejects socket paths that:
 - Contain `..` (directory traversal)
 - Are not absolute (do not start with `/`)
-- Exceed 256 characters
+- Exceed 104 characters (the AF_UNIX `sun_path` limit)
 
 Invalid paths fall back to the default socket path in the config directory.
 
@@ -151,7 +152,7 @@ handler logs a warning and exits cleanly without processing the payload.
 
 ### 10. Download File Handling
 
-**File:** `rust-crates/ctm/src/daemon/telegram_handlers.rs`
+**File:** `rust-crates/ctm/src/daemon/files.rs`
 
 Downloaded files from Telegram are handled with several protections:
 - The downloads directory is created with mode 0o700
@@ -179,11 +180,11 @@ Downloaded files from Telegram are handled with several protections:
 
 | Boundary | Validation | Enforcement |
 |---|---|---|
-| Socket messages: session ID | 128 char max, `[a-zA-Z0-9_-]` | `socket_handlers.rs` — `is_valid_session_id()` |
+| Socket messages: session ID | 128 char max, `[a-zA-Z0-9_.-]` | `socket_handlers.rs` — `is_valid_session_id()` |
 | Socket lines | 1 MiB max per NDJSON line | `socket.rs` — `MAX_LINE_BYTES` |
 | Socket connections | 64 concurrent max | `socket.rs` — `MAX_CONNECTIONS` |
 | Hook stdin | 1 MiB max | `hook.rs` — `MAX_STDIN_BYTES` |
-| Socket paths | No `..`, absolute only, 256 char max | `config.rs` — `validate_socket_path()` |
+| Socket paths | No `..`, absolute only, 104 char max | `config.rs` — `validate_socket_path()` |
 | Slash commands | Character whitelist: `[a-zA-Z0-9_- /]` | `injector.rs` — `is_valid_slash_command()` |
 | Download filenames | Sanitized, UUID-prefixed, no `..`, 200 char max | `telegram_handlers.rs` — `sanitize_filename()` |
 | Download file size | 20 MB max | Telegram Bot API server-side limit |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-telegram-mirror",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "description": "Bidirectional Telegram integration for Claude Code CLI - monitor and control your Claude Code sessions from Telegram",
   "bin": {
     "claude-telegram-mirror": "./scripts/ctm-wrapper.cjs",
@@ -49,10 +49,10 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "@agidreams/ctm-linux-x64": "0.2.23",
-    "@agidreams/ctm-linux-arm64": "0.2.23",
-    "@agidreams/ctm-darwin-arm64": "0.2.23",
-    "@agidreams/ctm-darwin-x64": "0.2.23"
+    "@agidreams/ctm-linux-x64": "0.2.25",
+    "@agidreams/ctm-linux-arm64": "0.2.25",
+    "@agidreams/ctm-darwin-arm64": "0.2.25",
+    "@agidreams/ctm-darwin-x64": "0.2.25"
   },
   "engines": {
     "node": ">=18.0.0"

package/postinstall.cjs

@@ -7,6 +7,71 @@
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
+const { execFileSync } = require('child_process');
+
+/**
+ * macOS hardening: a binary delivered via npm carries only the ad-hoc signature
+ * the build toolchain applied — it is NOT Developer-ID signed or notarized. On
+ * modern macOS the kernel can SIGKILL such a binary for a code-signing /
+ * launch-constraint violation (EXC_CRASH / "Code Signature Invalid"),
+ * especially on the first launchd-spawned launch after install. This pass is
+ * defense-in-depth: strip any quarantine flag, ensure the binary has a coherent
+ * (at least ad-hoc) signature, and smoke-test that it can actually exec. It
+ * never throws — install must still succeed — but it warns loudly so the user
+ * is not left with a binary the OS silently refuses to run.
+ */
+function hardenMacBinary(binary) {
+  if (process.platform !== 'darwin') return;
+
+  const run = (cmd, args) => {
+    try {
+      return { ok: true, out: execFileSync(cmd, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }) };
+    } catch (e) {
+      return { ok: false, out: (e.stdout || '') + (e.stderr || ''), err: e };
+    }
+  };
+
+  // 1. Remove the quarantine xattr if a download path applied one. Best-effort.
+  run('xattr', ['-d', 'com.apple.quarantine', binary]);
+
+  // 2. If the signature is missing/invalid, re-apply an ad-hoc signature so the
+  //    Mach-O is at least internally consistent and execable on Apple Silicon.
+  const verify = run('codesign', ['--verify', '--strict', binary]);
+  if (!verify.ok) {
+    const resign = run('codesign', ['--force', '--sign', '-', binary]);
+    if (!resign.ok) {
+      console.log('WARNING: Could not re-sign the native binary; macOS may refuse to run it.');
+      console.log('   Try manually: codesign --force --sign - "' + binary + '"');
+    }
+  }
+
+  // 3. Smoke-test exec. If the OS kills it here, the user would otherwise only
+  //    discover it when the daemon silently fails to start.
+  const smoke = run(binary, ['--version']);
+  if (!smoke.ok) {
+    console.log('');
+    console.log('WARNING: The native ctm binary failed to execute on this machine.');
+    console.log('   This is typically a macOS code-signing / Gatekeeper rejection of a');
+    console.log('   non-notarized binary. To inspect:');
+    console.log('     codesign -dvvv "' + binary + '"');
+    console.log('     ls ~/Library/Logs/DiagnosticReports/ctm-*.ips');
+    console.log('   Or build from source: cd rust-crates && cargo build --release');
+    console.log('');
+  }
+}
+
+// Protect the native binary on every real install — independent of whether we
+// also print the setup guidance below. Skipped under CI (the binary is built
+// and verified there, not consumed).
+if (!process.env.CI) {
+  try {
+    const { resolveBinary } = require('./scripts/resolve-binary.cjs');
+    const r = resolveBinary();
+    if (r) hardenMacBinary(r.binary);
+  } catch {
+    // resolve-binary unavailable — skip silently
+  }
+}
 
 // Don't show guidance during CI or if TELEGRAM_BOT_TOKEN is already set
 if (process.env.CI || process.env.TELEGRAM_BOT_TOKEN) {