claude-watchdog 0.1.0__tar.gz

claude_watchdog-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LinQuan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

claude_watchdog-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: claude-watchdog
+Version: 0.1.0
+Summary: Claude Code tmux watchdog — auto-unblock permission dialogs
+Author: LinQuan
+License: MIT
+Project-URL: homepage, https://github.com/mlinquan/claude-watchdog
+Project-URL: repository, https://github.com/mlinquan/claude-watchdog
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# claude-watchdog
+
+[English](./README.md) | [中文](./README.zh.md)
+
+Claude Code tmux watchdog — auto-unblock permission dialogs so you
+don't have to stare at a blocked session.
+
+Only logs hits (blockage detected and cleared), silent otherwise.
+
+## Install
+
+```bash
+pip install claude-watchdog
+```
+
+## Usage
+
+```bash
+# One-shot check (runs once, exits)
+claude-watchdog --session claude-tl
+
+# Monitor continuously
+claude-watchdog --session claude-tl --daemon
+
+# Monitor every claude-* session
+claude-watchdog --all --daemon
+
+# Alert only — log + notify, don't auto-approve
+claude-watchdog --session claude-tl --daemon --alert-only
+
+# View hit log
+claude-watchdog --log
+claude-watchdog --log --follow       # tail -f mode
+claude-watchdog --log --session claude-tl  # filter by session
+```
+
+## Notify on hit
+
+When a blockage is detected and cleared, claude-watchdog can notify you.
+Pass `--notify` (or `-n`) to enable. Examples:
+
+```bash
+# Integrated: via hermes-notify (bus message, silent progress type)
+claude-watchdog --session claude-tl --daemon --notify
+
+# DIY: pipe stdout to anything you want
+
+# HTTP webhook (Slack/Telegram/Discord/any API)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  curl -s -X POST https://hooks.slack.com/services/xxx/yyy/zzz \
+    -H "Content-Type: application/json" \
+    -d "{\"text\": \"$line\"}"
+
+  curl -s -X POST "https://api.telegram.org/bot<TOKEN>/sendMessage" \
+    -d "chat_id=<CHAT_ID>&text=$line"
+done
+
+# MCP notification (Model Context Protocol — tools with notifications)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  curl -s -X POST http://localhost:8080/mcp/notify \
+    -H "Content-Type: application/json" \
+    -d "{\"jsonrpc\": \"2.0\", \"method\": \"notifications/message\", \
+         \"params\": {\"severity\": \"warning\", \"message\": \"$line\"}}"
+done
+
+# macOS notification
+claude-watchdog --session claude-tl --daemon | while read line; do
+  osascript -e "display notification \"$line\" with title \"Watchdog\""
+done
+
+# WeChat (via notify-hermes.py)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  ~/.hermes/scripts/notify-hermes.py --type progress "Watchdog: $line"
+done
+```
+
+The `--notify` flag auto-detects `hermes-notify` if installed. No hard
+dependency — without it, `--notify` is a no-op.
+
+## Rules
+
+| Pattern | Keys | Description |
+|---------|------|-------------|
+| `Do you want to proceed` | 1 + Enter | Tool confirmation dialog |
+| `Do you want to (make this edit\|overwrite)` | Down + Enter | Allow all edits this session |
+| `accept edits on` | Enter | Accept pending diffs |
+| `bypass permissions on` | Enter | Bypass permission dialog |
+| `Detected a custom API key` | Up + Enter | Confirm custom API key |
+| `Interrupted` | 2 + Enter | Bypass/continue after interruption |
+| `Rate this response` / `评价` / `评分` | Escape | Dismiss evaluation dialog |
+
+New patterns can go into `~/.config/claude-watchdog/rules.toml` (future).
+
+## Log
+
+Hits are logged to `~/.local/share/claude-watchdog/hits.log` as JSONL:
+
+```json
+{"ts": "2026-05-18 09:15:23", "session": "claude-tl", "rule": "bypass_permissions", "detail": "Permission bypass prompt — confirm bypass"}
+```
+
+## Architecture
+
+```
+cli.py ── session/daemon/log ──→ watcher.py ── tmux capture-pane
+                                        │
+                                        ↓ rules.py
+                                   pattern match?
+                                   ├─ yes → send-keys + log [+ notify]
+                                   └─ no  → silent
+```

claude_watchdog-0.1.0/README.md

@@ -0,0 +1,111 @@
+# claude-watchdog
+
+[English](./README.md) | [中文](./README.zh.md)
+
+Claude Code tmux watchdog — auto-unblock permission dialogs so you
+don't have to stare at a blocked session.
+
+Only logs hits (blockage detected and cleared), silent otherwise.
+
+## Install
+
+```bash
+pip install claude-watchdog
+```
+
+## Usage
+
+```bash
+# One-shot check (runs once, exits)
+claude-watchdog --session claude-tl
+
+# Monitor continuously
+claude-watchdog --session claude-tl --daemon
+
+# Monitor every claude-* session
+claude-watchdog --all --daemon
+
+# Alert only — log + notify, don't auto-approve
+claude-watchdog --session claude-tl --daemon --alert-only
+
+# View hit log
+claude-watchdog --log
+claude-watchdog --log --follow       # tail -f mode
+claude-watchdog --log --session claude-tl  # filter by session
+```
+
+## Notify on hit
+
+When a blockage is detected and cleared, claude-watchdog can notify you.
+Pass `--notify` (or `-n`) to enable. Examples:
+
+```bash
+# Integrated: via hermes-notify (bus message, silent progress type)
+claude-watchdog --session claude-tl --daemon --notify
+
+# DIY: pipe stdout to anything you want
+
+# HTTP webhook (Slack/Telegram/Discord/any API)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  curl -s -X POST https://hooks.slack.com/services/xxx/yyy/zzz \
+    -H "Content-Type: application/json" \
+    -d "{\"text\": \"$line\"}"
+
+  curl -s -X POST "https://api.telegram.org/bot<TOKEN>/sendMessage" \
+    -d "chat_id=<CHAT_ID>&text=$line"
+done
+
+# MCP notification (Model Context Protocol — tools with notifications)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  curl -s -X POST http://localhost:8080/mcp/notify \
+    -H "Content-Type: application/json" \
+    -d "{\"jsonrpc\": \"2.0\", \"method\": \"notifications/message\", \
+         \"params\": {\"severity\": \"warning\", \"message\": \"$line\"}}"
+done
+
+# macOS notification
+claude-watchdog --session claude-tl --daemon | while read line; do
+  osascript -e "display notification \"$line\" with title \"Watchdog\""
+done
+
+# WeChat (via notify-hermes.py)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  ~/.hermes/scripts/notify-hermes.py --type progress "Watchdog: $line"
+done
+```
+
+The `--notify` flag auto-detects `hermes-notify` if installed. No hard
+dependency — without it, `--notify` is a no-op.
+
+## Rules
+
+| Pattern | Keys | Description |
+|---------|------|-------------|
+| `Do you want to proceed` | 1 + Enter | Tool confirmation dialog |
+| `Do you want to (make this edit\|overwrite)` | Down + Enter | Allow all edits this session |
+| `accept edits on` | Enter | Accept pending diffs |
+| `bypass permissions on` | Enter | Bypass permission dialog |
+| `Detected a custom API key` | Up + Enter | Confirm custom API key |
+| `Interrupted` | 2 + Enter | Bypass/continue after interruption |
+| `Rate this response` / `评价` / `评分` | Escape | Dismiss evaluation dialog |
+
+New patterns can go into `~/.config/claude-watchdog/rules.toml` (future).
+
+## Log
+
+Hits are logged to `~/.local/share/claude-watchdog/hits.log` as JSONL:
+
+```json
+{"ts": "2026-05-18 09:15:23", "session": "claude-tl", "rule": "bypass_permissions", "detail": "Permission bypass prompt — confirm bypass"}
+```
+
+## Architecture
+
+```
+cli.py ── session/daemon/log ──→ watcher.py ── tmux capture-pane
+                                        │
+                                        ↓ rules.py
+                                   pattern match?
+                                   ├─ yes → send-keys + log [+ notify]
+                                   └─ no  → silent
+```

claude_watchdog-0.1.0/claude_watchdog/cli.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+import argparse
+import subprocess
+import sys
+
+from .watcher import watch_loop, watch_all, get_sessions
+from .logger import read_log
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="claude-watchdog",
+        description="Claude Code tmux watchdog — auto-unblock permission dialogs",
+    )
+
+    # Monitor mode
+    parser.add_argument("--session", "-s", type=str, default=None,
+                        help="Session name to monitor (e.g. claude-tl)")
+    parser.add_argument("--all", "-a", action="store_true",
+                        help="Monitor all claude-* sessions")
+    parser.add_argument("--daemon", "-d", action="store_true",
+                        help="Run continuously until session ends")
+    parser.add_argument("--interval", "-i", type=int, default=10,
+                        help="Poll interval in seconds (default: 10)")
+    parser.add_argument("--notify", "-n", action="store_true",
+                        help="Send notification on hit via hermes-notify")
+    parser.add_argument("--alert-only", action="store_true",
+                        help="Log+notify only, do NOT auto-approve dialogs")
+
+    # Log mode
+    parser.add_argument("--log", "-l", action="store_true",
+                        help="View hit log")
+    parser.add_argument("--last", type=int, default=20,
+                        help="Last N log entries (default: 20)")
+    parser.add_argument("--follow", "-f", action="store_true",
+                        help="Tail -f the log")
+
+    args = parser.parse_args()
+
+    # --log mode
+    if args.log:
+        read_log(last=args.last, follow=args.follow, session_filter=args.session)
+        return
+
+    # --daemon without --session or --all: auto-detect
+    if args.daemon and not args.session and not args.all:
+        sessions = get_sessions()
+        if not sessions:
+            print("No claude-* tmux sessions found.")
+            sys.exit(1)
+        if len(sessions) == 1:
+            args.session = sessions[0]
+        else:
+            print(f"Multiple sessions found: {', '.join(sessions)}. Use --session or --all.")
+            sys.exit(1)
+
+    # Validate
+    if not args.session and not args.all:
+        parser.print_help()
+        sys.exit(1)
+
+    # One-shot check
+    if not args.daemon:
+        from .watcher import check_session
+        if args.all:
+            sessions = get_sessions()
+            for s in sessions:
+                check_session(s, args.notify, args.alert_only)
+        else:
+            from .watcher import session_exists
+            if not session_exists(args.session):
+                print(f"Session '{args.session}' not found.")
+                sys.exit(1)
+            check_session(args.session, args.notify, args.alert_only)
+        return
+
+    # Daemon mode
+    if args.all:
+        print(f"Watching all claude-* sessions (interval={args.interval}s)")
+        watch_all(interval=args.interval, use_notify=args.notify, alert_only=args.alert_only)
+    else:
+        print(f"Watching session '{args.session}' (interval={args.interval}s)")
+        watch_loop(args.session, interval=args.interval, use_notify=args.notify, alert_only=args.alert_only)
+
+
+if __name__ == "__main__":
+    main()

claude_watchdog-0.1.0/claude_watchdog/logger.py

@@ -0,0 +1,53 @@
+import json
+import os
+import time
+from datetime import datetime
+
+LOG_DIR = os.path.expanduser("~/.local/share/claude-watchdog")
+LOG_FILE = os.path.join(LOG_DIR, "hits.log")
+
+
+def _ensure_log_dir():
+    os.makedirs(LOG_DIR, exist_ok=True)
+
+
+def log_hit(session: str, rule_name: str, detail: str):
+    _ensure_log_dir()
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = json.dumps({"ts": ts, "session": session, "rule": rule_name, "detail": detail})
+    with open(LOG_FILE, "a") as f:
+        f.write(line + "\n")
+    # Also print to stdout so --daemon runner sees it
+    print(f"[{ts}] ⛔ {session}: {detail}")
+
+
+def read_log(last: int = 20, follow: bool = False, session_filter: str | None = None):
+    _ensure_log_dir()
+    if not os.path.exists(LOG_FILE):
+        print("No hits yet.")
+        return
+
+    if follow:
+        import subprocess
+        cmd = ["tail", "-f", LOG_FILE]
+        if last:
+            cmd.insert(1, f"-n{last}")
+        proc = subprocess.run(cmd)
+        proc.check_returncode()
+        return
+
+    lines = []
+    with open(LOG_FILE) as f:
+        for line in f:
+            lines.append(line)
+
+    for line in lines[-last:]:
+        try:
+            entry = json.loads(line)
+            if session_filter and entry.get("session") != session_filter:
+                continue
+            ts = entry["ts"]
+            detail = entry["detail"]
+            print(f"[{ts}] ⛔ {detail}")
+        except json.JSONDecodeError:
+            print(line.strip())

claude_watchdog-0.1.0/claude_watchdog/notify.py

@@ -0,0 +1,25 @@
+"""Optional notify integration — bridges to hermes-notify if available."""
+import shutil
+import subprocess
+import shlex
+
+
+def _notify_cmd() -> str | None:
+    """Return notify CLI path if installed."""
+    return shutil.which("hermes-notify") or shutil.which("notify")
+
+
+def send_hit(session: str, rule_name: str, detail: str):
+    cmd = _notify_cmd()
+    if not cmd:
+        return  # notify not installed, silent skip
+    try:
+        text = shlex.quote(f"[watchdog] {session}: {detail}")
+        subprocess.run(
+            f"{cmd} send --type progress --text {text}",
+            shell=True,
+            timeout=5,
+            capture_output=True,
+        )
+    except Exception:
+        pass  # notify failure is non-critical

claude_watchdog-0.1.0/claude_watchdog/rules.py

@@ -0,0 +1,47 @@
+# Rule: list of dialog patterns with match regex and keystroke sequence
+# Each entry: (name, regex, keys, description)
+
+RULES = [
+    (
+        "proceed",
+        r"Do you want to proceed",
+        ["1", "Enter"],
+        "Tool confirmation dialog — select option 1 (Yes)",
+    ),
+    (
+        "edit_or_overwrite",
+        r"Do you want to (make this edit|overwrite)",
+        ["Down", "Enter"],
+        "File edit/overwrite dialog — 'Allow all this session'",
+    ),
+    (
+        "accept_edits",
+        r"accept edits on",
+        ["Enter"],
+        "Diff review prompt — accept pending diffs",
+    ),
+    (
+        "bypass_permissions",
+        r"bypass permissions on",
+        ["Enter"],
+        "Permission bypass prompt — confirm bypass",
+    ),
+    (
+        "custom_api_key",
+        r"Detected a custom API key",
+        ["Up", "Enter"],
+        "API key detection — confirm custom key (select Yes)",
+    ),
+    (
+        "interrupted",
+        r"Interrupted",
+        ["2", "Enter"],
+        "Interrupted dialog — select option 2 (Bypass/Continue)",
+    ),
+    (
+        "rate_claude",
+        r"(Rate this response|How was this)",
+        ["Escape"],
+        "Rating/evaluation dialog — dismiss (press Escape)",
+    ),
+]

claude_watchdog-0.1.0/claude_watchdog/watcher.py

@@ -0,0 +1,89 @@
+import re
+import subprocess
+import time
+
+from .rules import RULES
+from .logger import log_hit
+
+
+def get_sessions() -> list[str]:
+    """List all running tmux sessions whose name starts with 'claude-'."""
+    try:
+        result = subprocess.run(
+            ["tmux", "list-sessions", "-F", "#{session_name}"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return [s.strip() for s in result.stdout.splitlines() if s.strip().startswith("claude-")]
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return []
+
+
+def session_exists(session: str) -> bool:
+    try:
+        subprocess.run(
+            ["tmux", "has-session", "-t", session],
+            capture_output=True, timeout=3, check=True,
+        )
+        return True
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+
+def capture_pane(session: str, lines: int = 15) -> str:
+    try:
+        result = subprocess.run(
+            ["tmux", "capture-pane", "-t", session, "-p", "-S", f"-{lines}"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return ""
+
+
+def send_keys(session: str, keys: list[str]):
+    import shlex
+    for key in keys:
+        subprocess.run(
+            ["tmux", "send-keys", "-t", session, key],
+            capture_output=True, timeout=3,
+        )
+
+
+def check_session(session: str, use_notify: bool = False, alert_only: bool = False) -> bool:
+    """
+    Check a single session for blocked dialogs.
+    Returns True if a dialog was detected and cleared.
+    """
+    output = capture_pane(session)
+    if not output:
+        return False
+
+    for name, pattern, keys, desc in RULES:
+        if re.search(pattern, output, re.MULTILINE):
+            if not alert_only:
+                send_keys(session, keys)
+            log_hit(session, name, desc)
+            if use_notify:
+                from .notify import send_hit
+                send_hit(session, name, desc)
+            return True
+    return False
+
+
+def watch_loop(session: str, interval: int = 10, use_notify: bool = False, alert_only: bool = False):
+    """Continuously monitor a session until it disappears."""
+    while session_exists(session):
+        check_session(session, use_notify, alert_only)
+        time.sleep(interval)
+
+
+def watch_all(interval: int = 10, use_notify: bool = False, alert_only: bool = False):
+    """Monitor all claude-* sessions in a round-robin."""
+    while True:
+        sessions = get_sessions()
+        if not sessions:
+            time.sleep(interval)
+            continue
+        for s in sessions:
+            check_session(s, use_notify, alert_only)
+        time.sleep(interval)

claude_watchdog-0.1.0/claude_watchdog.egg-info/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: claude-watchdog
+Version: 0.1.0
+Summary: Claude Code tmux watchdog — auto-unblock permission dialogs
+Author: LinQuan
+License: MIT
+Project-URL: homepage, https://github.com/mlinquan/claude-watchdog
+Project-URL: repository, https://github.com/mlinquan/claude-watchdog
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# claude-watchdog
+
+[English](./README.md) | [中文](./README.zh.md)
+
+Claude Code tmux watchdog — auto-unblock permission dialogs so you
+don't have to stare at a blocked session.
+
+Only logs hits (blockage detected and cleared), silent otherwise.
+
+## Install
+
+```bash
+pip install claude-watchdog
+```
+
+## Usage
+
+```bash
+# One-shot check (runs once, exits)
+claude-watchdog --session claude-tl
+
+# Monitor continuously
+claude-watchdog --session claude-tl --daemon
+
+# Monitor every claude-* session
+claude-watchdog --all --daemon
+
+# Alert only — log + notify, don't auto-approve
+claude-watchdog --session claude-tl --daemon --alert-only
+
+# View hit log
+claude-watchdog --log
+claude-watchdog --log --follow       # tail -f mode
+claude-watchdog --log --session claude-tl  # filter by session
+```
+
+## Notify on hit
+
+When a blockage is detected and cleared, claude-watchdog can notify you.
+Pass `--notify` (or `-n`) to enable. Examples:
+
+```bash
+# Integrated: via hermes-notify (bus message, silent progress type)
+claude-watchdog --session claude-tl --daemon --notify
+
+# DIY: pipe stdout to anything you want
+
+# HTTP webhook (Slack/Telegram/Discord/any API)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  curl -s -X POST https://hooks.slack.com/services/xxx/yyy/zzz \
+    -H "Content-Type: application/json" \
+    -d "{\"text\": \"$line\"}"
+
+  curl -s -X POST "https://api.telegram.org/bot<TOKEN>/sendMessage" \
+    -d "chat_id=<CHAT_ID>&text=$line"
+done
+
+# MCP notification (Model Context Protocol — tools with notifications)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  curl -s -X POST http://localhost:8080/mcp/notify \
+    -H "Content-Type: application/json" \
+    -d "{\"jsonrpc\": \"2.0\", \"method\": \"notifications/message\", \
+         \"params\": {\"severity\": \"warning\", \"message\": \"$line\"}}"
+done
+
+# macOS notification
+claude-watchdog --session claude-tl --daemon | while read line; do
+  osascript -e "display notification \"$line\" with title \"Watchdog\""
+done
+
+# WeChat (via notify-hermes.py)
+claude-watchdog --session claude-tl --daemon | while read line; do
+  ~/.hermes/scripts/notify-hermes.py --type progress "Watchdog: $line"
+done
+```
+
+The `--notify` flag auto-detects `hermes-notify` if installed. No hard
+dependency — without it, `--notify` is a no-op.
+
+## Rules
+
+| Pattern | Keys | Description |
+|---------|------|-------------|
+| `Do you want to proceed` | 1 + Enter | Tool confirmation dialog |
+| `Do you want to (make this edit\|overwrite)` | Down + Enter | Allow all edits this session |
+| `accept edits on` | Enter | Accept pending diffs |
+| `bypass permissions on` | Enter | Bypass permission dialog |
+| `Detected a custom API key` | Up + Enter | Confirm custom API key |
+| `Interrupted` | 2 + Enter | Bypass/continue after interruption |
+| `Rate this response` / `评价` / `评分` | Escape | Dismiss evaluation dialog |
+
+New patterns can go into `~/.config/claude-watchdog/rules.toml` (future).
+
+## Log
+
+Hits are logged to `~/.local/share/claude-watchdog/hits.log` as JSONL:
+
+```json
+{"ts": "2026-05-18 09:15:23", "session": "claude-tl", "rule": "bypass_permissions", "detail": "Permission bypass prompt — confirm bypass"}
+```
+
+## Architecture
+
+```
+cli.py ── session/daemon/log ──→ watcher.py ── tmux capture-pane
+                                        │
+                                        ↓ rules.py
+                                   pattern match?
+                                   ├─ yes → send-keys + log [+ notify]
+                                   └─ no  → silent
+```

claude_watchdog-0.1.0/claude_watchdog.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+claude_watchdog/cli.py
+claude_watchdog/logger.py
+claude_watchdog/notify.py
+claude_watchdog/rules.py
+claude_watchdog/watcher.py
+claude_watchdog.egg-info/PKG-INFO
+claude_watchdog.egg-info/SOURCES.txt
+claude_watchdog.egg-info/dependency_links.txt
+claude_watchdog.egg-info/entry_points.txt
+claude_watchdog.egg-info/top_level.txt

claude_watchdog-0.1.0/claude_watchdog.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

claude_watchdog-0.1.0/claude_watchdog.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+claude-watchdog = claude_watchdog.cli:main

claude_watchdog-0.1.0/claude_watchdog.egg-info/top_level.txt

@@ -0,0 +1 @@
+claude_watchdog

claude_watchdog-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "claude-watchdog"
+version = "0.1.0"
+description = "Claude Code tmux watchdog — auto-unblock permission dialogs"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "LinQuan"}]
+requires-python = ">=3.10"
+dependencies = []
+
+[project.urls]
+homepage = "https://github.com/mlinquan/claude-watchdog"
+repository = "https://github.com/mlinquan/claude-watchdog"
+
+[project.scripts]
+claude-watchdog = "claude_watchdog.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["claude_watchdog*"]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

claude_watchdog-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+