claudehub-hooks 0.1.0__tar.gz

claudehub_hooks-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pandiyaraj Karuppasamy
+
+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.

claudehub_hooks-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: claudehub-hooks
+Version: 0.1.0
+Summary: Claude Code hook dispatcher — forwards lifecycle events to Claude Monitor
+Author-email: Pandiyaraj Karuppasamy <pandiyarajk@live.com>
+License-Expression: MIT
+Keywords: claude,claude-code,claudehub,hooks,monitor,dispatcher
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# claudehub-hooks
+
+Pip-installable [Claude Code](https://docs.anthropic.com/en/docs/claude-code) hook dispatcher.
+Install once, then wire any repository to a Claude Monitor HTTP
+endpoint in one command — no manual script copying or JSON editing.
+
+Events flow: **Claude Code → claudehub-hooks dispatcher → Claude Monitor**.
+
+## Install
+
+```bash
+pip install claudehub-hooks
+```
+
+Requires Python 3.10+. No third-party runtime dependencies (stdlib only).
+
+## Quick start
+
+```bash
+claudehub-hooks install
+```
+
+Run from a repository root (or pass `--repo`). The command is **idempotent** — safe to re-run.
+
+```bash
+claudehub-hooks install --repo /path/to/repo
+claudehub-hooks install --url http://192.168.1.50:7070/event
+claudehub-hooks install --dry-run
+```
+
+### What it writes
+
+| File | Purpose |
+|------|---------|
+| `.claude/hooks/claude_hook.py` | Hook dispatcher (invoked by Claude Code) |
+| `.claude/hooks/monitor_config.json` | Transport config with the monitor URL |
+| `.claude/settings.json` | Nine hook entries merged in (existing entries kept) |
+
+## Change the monitor URL
+
+Edit `.claude/hooks/monitor_config.json` in the repo:
+
+```json
+{
+  "transport": {
+    "http": { "url": "http://192.168.1.50:7070/event" }
+  }
+}
+```
+
+Or set an environment variable (overrides the file):
+
+```bash
+export CLAUDE_HUB_URL="http://192.168.1.50:7070/event"
+```
+
+On Windows (persistent):
+
+```bat
+setx CLAUDE_HUB_URL "http://192.168.1.50:7070/event"
+```
+
+## Test connectivity
+
+```bash
+python .claude/hooks/claude_hook.py --test
+```
+
+## Hooks installed
+
+| Event | Trigger |
+|-------|---------|
+| `SessionStart` | Claude session begins |
+| `UserPromptSubmit` | User sends a message |
+| `Notification` | Claude needs input |
+| `PostToolUse` | File read/edited (Edit · Write · NotebookEdit · MultiEdit · Read) |
+| `Stop` | Turn completes |
+| `StopFailure` | API error |
+| `PermissionRequest` | Allow/deny dialog shown |
+| `PermissionDenied` | User denied a tool |
+| `PreToolUse` | Tool about to run (resolves permission) |
+
+## Configuration
+
+| Variable | Default | Meaning |
+|----------|---------|---------|
+| `CLAUDE_HUB_URL` | `http://127.0.0.1:7070/event` | Monitor endpoint |
+| `CLAUDE_HUB_TIMEOUT` | `2.0` | HTTP timeout (seconds) |
+| `CLAUDE_HUB_HTTP_ENABLED` | `true` | Set to `false` to silence all hooks |
+| `CLAUDE_HOOK_LOG_LEVEL` | `INFO` | Dispatcher log level |
+| `CLAUDE_HOOK_LOG_FILE` | `~/.claude/claude_hook.log` | Override log path |
+| `CLAUDE_HUB_CONFIG` | — | Path to a `monitor_config.json` override |
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+**Author:** Pandiyaraj Karuppasamy · pandiyarajk@live.com

claudehub_hooks-0.1.0/README.md

@@ -0,0 +1,98 @@
+# claudehub-hooks
+
+Pip-installable [Claude Code](https://docs.anthropic.com/en/docs/claude-code) hook dispatcher.
+Install once, then wire any repository to a Claude Monitor HTTP
+endpoint in one command — no manual script copying or JSON editing.
+
+Events flow: **Claude Code → claudehub-hooks dispatcher → Claude Monitor**.
+
+## Install
+
+```bash
+pip install claudehub-hooks
+```
+
+Requires Python 3.10+. No third-party runtime dependencies (stdlib only).
+
+## Quick start
+
+```bash
+claudehub-hooks install
+```
+
+Run from a repository root (or pass `--repo`). The command is **idempotent** — safe to re-run.
+
+```bash
+claudehub-hooks install --repo /path/to/repo
+claudehub-hooks install --url http://192.168.1.50:7070/event
+claudehub-hooks install --dry-run
+```
+
+### What it writes
+
+| File | Purpose |
+|------|---------|
+| `.claude/hooks/claude_hook.py` | Hook dispatcher (invoked by Claude Code) |
+| `.claude/hooks/monitor_config.json` | Transport config with the monitor URL |
+| `.claude/settings.json` | Nine hook entries merged in (existing entries kept) |
+
+## Change the monitor URL
+
+Edit `.claude/hooks/monitor_config.json` in the repo:
+
+```json
+{
+  "transport": {
+    "http": { "url": "http://192.168.1.50:7070/event" }
+  }
+}
+```
+
+Or set an environment variable (overrides the file):
+
+```bash
+export CLAUDE_HUB_URL="http://192.168.1.50:7070/event"
+```
+
+On Windows (persistent):
+
+```bat
+setx CLAUDE_HUB_URL "http://192.168.1.50:7070/event"
+```
+
+## Test connectivity
+
+```bash
+python .claude/hooks/claude_hook.py --test
+```
+
+## Hooks installed
+
+| Event | Trigger |
+|-------|---------|
+| `SessionStart` | Claude session begins |
+| `UserPromptSubmit` | User sends a message |
+| `Notification` | Claude needs input |
+| `PostToolUse` | File read/edited (Edit · Write · NotebookEdit · MultiEdit · Read) |
+| `Stop` | Turn completes |
+| `StopFailure` | API error |
+| `PermissionRequest` | Allow/deny dialog shown |
+| `PermissionDenied` | User denied a tool |
+| `PreToolUse` | Tool about to run (resolves permission) |
+
+## Configuration
+
+| Variable | Default | Meaning |
+|----------|---------|---------|
+| `CLAUDE_HUB_URL` | `http://127.0.0.1:7070/event` | Monitor endpoint |
+| `CLAUDE_HUB_TIMEOUT` | `2.0` | HTTP timeout (seconds) |
+| `CLAUDE_HUB_HTTP_ENABLED` | `true` | Set to `false` to silence all hooks |
+| `CLAUDE_HOOK_LOG_LEVEL` | `INFO` | Dispatcher log level |
+| `CLAUDE_HOOK_LOG_FILE` | `~/.claude/claude_hook.log` | Override log path |
+| `CLAUDE_HUB_CONFIG` | — | Path to a `monitor_config.json` override |
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+**Author:** Pandiyaraj Karuppasamy · pandiyarajk@live.com

claudehub_hooks-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "claudehub-hooks"
+dynamic = ["version"]
+description = "Claude Code hook dispatcher — forwards lifecycle events to Claude Monitor"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Pandiyaraj Karuppasamy", email = "pandiyarajk@live.com"}]
+keywords = ["claude", "claude-code", "claudehub", "hooks", "monitor", "dispatcher"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.scripts]
+claudehub-hooks = "claudehub_hooks.cli:main"
+
+[tool.setuptools.dynamic]
+version = {attr = "claudehub_hooks.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

claudehub_hooks-0.1.0/setup.cfg

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

claudehub_hooks-0.1.0/src/claudehub_hooks/__init__.py

@@ -0,0 +1,4 @@
+"""Claude Code hook dispatcher package."""
+
+__version__ = "0.1.0"
+__all__ = ["__version__"]

claudehub_hooks-0.1.0/src/claudehub_hooks/_settings.py

@@ -0,0 +1,63 @@
+"""settings.json read / merge / atomic-write helpers."""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+
+def read_settings(path: Path) -> dict:
+    """Load a JSON settings file; return {} on missing or malformed file."""
+    try:
+        with path.open(encoding="utf-8") as fh:
+            data = json.load(fh)
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def merge_hooks(existing: dict, new_block: dict) -> tuple[dict, list[str], list[str]]:
+    """Merge *new_block* into *existing["hooks"]*, skipping entries that already
+    have a ``claude_hook.py`` entry for the same event.
+
+    Returns ``(updated_dict, added_events, skipped_events)``.
+    """
+    hooks = existing.setdefault("hooks", {})
+    added: list[str] = []
+    skipped: list[str] = []
+
+    for event, entries in new_block.items():
+        if event in hooks and _has_claude_hook_entry(hooks[event]):
+            skipped.append(event)
+            continue
+        hooks[event] = entries
+        added.append(event)
+
+    return existing, added, skipped
+
+
+def _has_claude_hook_entry(entries: list) -> bool:
+    """Return True if any entry in the list references ``claude_hook.py``."""
+    for entry in entries:
+        for hook in entry.get("hooks", []):
+            args = hook.get("args", [])
+            if any("claude_hook.py" in str(a) for a in args):
+                return True
+    return False
+
+
+def write_settings(path: Path, data: dict) -> None:
+    """Atomically write *data* as JSON to *path* (write temp → rename)."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=".settings_", suffix=".json")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            json.dump(data, fh, indent=2, ensure_ascii=False)
+            fh.write("\n")
+        os.replace(tmp, path)
+    except Exception:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise

claudehub_hooks-0.1.0/src/claudehub_hooks/cli.py

@@ -0,0 +1,189 @@
+"""claudehub-hooks CLI — install the hook dispatcher into any repo."""
+
+import argparse
+import json
+import shutil
+import sys
+from pathlib import Path
+
+from . import __version__
+from ._settings import merge_hooks, read_settings, write_settings
+
+# ---------------------------------------------------------------------------
+# Hook block — the 9 entries written into .claude/settings.json
+# ---------------------------------------------------------------------------
+
+def _entry(event: str) -> list:
+    """Standard hook entry for an event (no matcher)."""
+    return [{"hooks": [{"type": "command", "command": "python",
+                        "args": [f"${{CLAUDE_PROJECT_DIR}}/.claude/hooks/claude_hook.py", event]}]}]
+
+
+def _entry_with_matcher(event: str, matcher: str) -> list:
+    """Hook entry with a tool matcher (PostToolUse only)."""
+    return [{"matcher": matcher, "hooks": [{"type": "command", "command": "python",
+             "args": [f"${{CLAUDE_PROJECT_DIR}}/.claude/hooks/claude_hook.py", event]}]}]
+
+
+_HOOKS_BLOCK: dict = {
+    "SessionStart":      _entry("SessionStart"),
+    "UserPromptSubmit":  _entry("UserPromptSubmit"),
+    "Notification":      _entry("Notification"),
+    "PostToolUse":       _entry_with_matcher("PostToolUse", "Edit|Write|NotebookEdit|MultiEdit|Read"),
+    "Stop":              _entry("Stop"),
+    "StopFailure":       _entry("StopFailure"),
+    "PermissionRequest": _entry("PermissionRequest"),
+    "PermissionDenied":  _entry("PermissionDenied"),
+    "PreToolUse":        _entry("PreToolUse"),
+}
+
+# ---------------------------------------------------------------------------
+# Default monitor_config.json written next to hook.py
+# ---------------------------------------------------------------------------
+
+def _monitor_config(url: str) -> dict:
+    return {
+        "transport": {
+            "http": {
+                "enabled": True,
+                "url": url,
+                "timeout_s": 2.0,
+            }
+        },
+        "logging": {
+            "level": "INFO",
+            "file": "",
+            "max_bytes": 524288,
+            "backup_count": 3,
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# Install command
+# ---------------------------------------------------------------------------
+
+def cmd_install(args: argparse.Namespace) -> int:
+    repo = Path(args.repo).resolve()
+    url  = args.url
+    dry  = args.dry_run
+
+    # Paths
+    hooks_dir      = repo / ".claude" / "hooks"
+    hook_dst       = hooks_dir / "claude_hook.py"
+    config_dst     = hooks_dir / "monitor_config.json"
+    settings_path  = repo / ".claude" / "settings.json"
+
+    # Warn if not a git repo
+    if not (repo / ".git").exists():
+        print(f"  [warn]  {repo} has no .git directory -- continuing anyway")
+
+    print(f"  repo:    {repo}")
+    print(f"  monitor: {url}")
+    print()
+
+    # --- 1. Copy hook.py ---
+    hook_src = Path(__file__).parent / "hook.py"
+    if hook_dst.exists():
+        print(f"  [skip]   {hook_dst.relative_to(repo)}  (already exists)")
+    else:
+        print(f"  [write]  {hook_dst.relative_to(repo)}")
+        if not dry:
+            hooks_dir.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(hook_src, hook_dst)
+
+    # --- 2. Write monitor_config.json ---
+    if config_dst.exists():
+        print(f"  [skip]   {config_dst.relative_to(repo)}  (already exists)")
+    else:
+        print(f"  [write]  {config_dst.relative_to(repo)}")
+        if not dry:
+            hooks_dir.mkdir(parents=True, exist_ok=True)
+            config_dst.write_text(
+                json.dumps(_monitor_config(url), indent=2) + "\n",
+                encoding="utf-8",
+            )
+
+    # --- 3. Merge hooks into settings.json ---
+    existing = read_settings(settings_path)
+    updated, added, skipped = merge_hooks(existing, _HOOKS_BLOCK)
+
+    if added:
+        print(f"  [merge]  {settings_path.relative_to(repo)}")
+        for ev in added:
+            print(f"           + {ev}")
+        if not dry:
+            write_settings(settings_path, updated)
+    else:
+        print(f"  [skip]   {settings_path.relative_to(repo)}  (all hooks already present)")
+
+    if skipped:
+        print(f"  [skip]   hooks already present: {', '.join(skipped)}")
+
+    print()
+    if dry:
+        print("  (dry-run -- nothing written)")
+    else:
+        print("  Done. Start claude_monitor.py, then open Claude Code in this repo.")
+        print(f"  To change the monitor URL, edit: {config_dst.relative_to(repo)}")
+        print(f"  Or set:  CLAUDE_HUB_URL={url}")
+
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Argument parser
+# ---------------------------------------------------------------------------
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="claudehub-hooks",
+        description="Install Claude Code hook dispatcher into a repository.",
+    )
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+
+    sub = p.add_subparsers(dest="command", metavar="<command>")
+    sub.required = True
+
+    install = sub.add_parser(
+        "install",
+        help="Install the hook dispatcher into a repo.",
+        description=(
+            "Copies claude_hook.py into <repo>/.claude/hooks/, writes "
+            "monitor_config.json, and merges hook entries into "
+            "<repo>/.claude/settings.json."
+        ),
+    )
+    install.add_argument(
+        "--repo",
+        default=".",
+        metavar="PATH",
+        help="Target repository root (default: current directory).",
+    )
+    install.add_argument(
+        "--url",
+        default="http://127.0.0.1:7070/event",
+        metavar="URL",
+        help="Claude Monitor HTTP endpoint (default: http://127.0.0.1:7070/event).",
+    )
+    install.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print what would change without writing anything.",
+    )
+    return p
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.command == "install":
+        sys.exit(cmd_install(args))
+    else:
+        parser.print_help()
+        sys.exit(1)

claudehub_hooks-0.1.0/src/claudehub_hooks/hook.py

@@ -0,0 +1,333 @@
+"""Claude Code hook -> Claude Monitor dispatcher.
+
+Reads the hook payload from stdin, builds a structured event, and transmits it
+to the Claude Monitor over HTTP (TCP).
+
+When installed via ``claudehub-hooks install``, this file is copied to:
+    <repo>/.claude/hooks/claude_hook.py
+
+and invoked by Claude Code as:
+    python .claude/hooks/claude_hook.py <EventName>
+
+Self-test (verify connectivity):
+    python claude_hook.py --test
+
+The script is fail-safe: transport errors are logged and printed to stderr,
+but the script always exits 0 so it never blocks the Claude session.
+
+Config search order:
+  1. CLAUDE_HUB_CONFIG env var path
+  2. Same directory as this script  (monitor_config.json)
+  3. ~/.claude/monitor_config.json
+
+All config keys are overridable with CLAUDE_HUB_* env vars.
+
+Payload schema:
+  {
+    "event":            "SessionStart" | "UserPromptSubmit" | ... | "Unknown",
+    "datetime":         "<ISO-8601 UTC>",
+    "session_id":       "<str>",
+    "host":             "<hostname>",
+    "cwd":              "<working dir>",          # when available
+    "files":            ["<path>", ...],          # PostToolUse only
+    "prompt":           "<first 500 chars>",      # UserPromptSubmit only
+    "tool_name":        "<tool>",                 # PostToolUse / PermissionRequest
+    "notification_type":"<type>",                 # Notification only
+    "command":          "<cmd>",                  # PermissionRequest/Denied/PreToolUse
+    "error_type":       "<type>",                 # StopFailure only
+    "error_message":    "<msg>",                  # StopFailure only
+  }
+"""
+
+import json
+import logging
+import logging.handlers
+import os
+import socket
+import sys
+import time
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+_DEFAULTS: dict = {
+    "transport": {
+        "http": {"enabled": True, "url": "http://127.0.0.1:7070/event", "timeout_s": 2.0},
+    },
+    "monitor": {
+        "http_host": "0.0.0.0", "http_port": 7070,
+        "history_max": 300,
+    },
+    "logging": {
+        "level":        "INFO",
+        "file":         "",       # empty → ~/.claude/claude_hook.log
+        "max_bytes":    524288,   # 512 KB
+        "backup_count": 3,
+    },
+}
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Recursively merge *override* into a copy of *base*."""
+    result = base.copy()
+    for k, v in override.items():
+        if isinstance(v, dict) and isinstance(result.get(k), dict):
+            result[k] = _deep_merge(result[k], v)
+        else:
+            result[k] = v
+    return result
+
+
+def load_config() -> dict:
+    """Load config from JSON file then apply env var overrides.
+
+    Search order for the config file:
+      1. CLAUDE_HUB_CONFIG env var path
+      2. Same directory as this script
+      3. ~/.claude/monitor_config.json
+    Falls back to built-in defaults if no file is found.
+    """
+    cfg = _deep_merge({}, _DEFAULTS)
+
+    candidates: list[Path] = []
+    if os.environ.get("CLAUDE_HUB_CONFIG"):
+        candidates.append(Path(os.environ["CLAUDE_HUB_CONFIG"]))
+    candidates.append(Path(__file__).parent / "monitor_config.json")
+    candidates.append(Path.home() / ".claude" / "monitor_config.json")
+
+    for path in candidates:
+        try:
+            with path.open(encoding="utf-8") as fh:
+                cfg = _deep_merge(cfg, json.load(fh))
+            break
+        except (OSError, ValueError):
+            continue
+
+    def _bool(v: str) -> bool:
+        return v.strip().lower() not in ("0", "false", "no", "off")
+
+    ev = os.environ
+    if "CLAUDE_HUB_HTTP_ENABLED" in ev: cfg["transport"]["http"]["enabled"]   = _bool(ev["CLAUDE_HUB_HTTP_ENABLED"])  # noqa: E701
+    if "CLAUDE_HUB_URL"      in ev: cfg["transport"]["http"]["url"]       = ev["CLAUDE_HUB_URL"]              # noqa: E701
+    if "CLAUDE_HUB_TIMEOUT"  in ev: cfg["transport"]["http"]["timeout_s"] = float(ev["CLAUDE_HUB_TIMEOUT"])   # noqa: E701
+    if "CLAUDE_HOOK_LOG_LEVEL"    in ev: cfg["logging"]["level"]               = ev["CLAUDE_HOOK_LOG_LEVEL"].upper()    # noqa: E701
+    if "CLAUDE_HOOK_LOG_FILE"     in ev: cfg["logging"]["file"]                = ev["CLAUDE_HOOK_LOG_FILE"]             # noqa: E701
+
+    return cfg
+
+
+def _setup_logging(cfg: dict) -> logging.Logger:
+    """Configure a rotating-file logger. Never raises (falls back to NullHandler)."""
+    lcfg = cfg.get("logging", {})
+    level = getattr(logging, lcfg.get("level", "INFO"), logging.INFO)
+
+    log_path_str = lcfg.get("file") or ""
+    log_path = Path(log_path_str) if log_path_str else Path.home() / ".claude" / "claude_hook.log"
+
+    logger = logging.getLogger("claude_hook")
+    logger.setLevel(level)
+
+    if logger.handlers:
+        return logger   # already configured
+
+    fmt = logging.Formatter(
+        "%(asctime)s  %(levelname)-8s  %(message)s",
+        datefmt="%Y-%m-%dT%H:%M:%S",
+    )
+    try:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        fh = logging.handlers.RotatingFileHandler(
+            log_path,
+            maxBytes=int(lcfg.get("max_bytes", 524288)),
+            backupCount=int(lcfg.get("backup_count", 3)),
+            encoding="utf-8",
+        )
+        fh.setFormatter(fmt)
+        logger.addHandler(fh)
+    except OSError:
+        logger.addHandler(logging.NullHandler())
+
+    return logger
+
+
+# ---------------------------------------------------------------------------
+# Payload helpers
+# ---------------------------------------------------------------------------
+
+def _extract_files(label: str, payload: dict) -> list[str]:
+    """Extract file paths from a PostToolUse payload."""
+    if label != "PostToolUse":
+        return []
+    tool_input = payload.get("tool_input") or {}
+    files: list[str] = []
+    for key in ("file_path", "notebook_path", "path"):
+        val = tool_input.get(key)
+        if val and val not in files:
+            files.append(val)
+    return files
+
+
+def _build_body(label: str, payload: dict) -> dict:
+    """Assemble the outgoing event dict.
+
+    Color is intentionally omitted — the monitor derives it client-side from
+    the event name.
+    """
+    body: dict = {
+        "event":      label,
+        "datetime":   datetime.now(timezone.utc).isoformat(),
+        "session_id": payload.get("session_id"),
+        "host":       socket.gethostname(),
+    }
+
+    if payload.get("cwd"):
+        body["cwd"] = payload["cwd"]
+
+    files = _extract_files(label, payload)
+    if files:
+        body["files"] = files
+
+    if label == "UserPromptSubmit" and payload.get("prompt"):
+        body["prompt"] = payload["prompt"][:500]
+
+    if label == "PostToolUse" and payload.get("tool_name"):
+        body["tool_name"] = payload["tool_name"]
+
+    if label == "Notification" and payload.get("notification_type"):
+        body["notification_type"] = payload["notification_type"]
+
+    if label in ("PermissionRequest", "PermissionDenied", "PreToolUse"):
+        if payload.get("tool_name"):
+            body["tool_name"] = payload["tool_name"]
+        tool_input = payload.get("tool_input") or {}
+        requested = (
+            tool_input.get("command")
+            or tool_input.get("file_path")
+            or tool_input.get("notebook_path")
+        )
+        if requested:
+            body["command"] = requested[:300]
+
+    if label == "StopFailure":
+        if payload.get("error_type"):
+            body["error_type"] = payload["error_type"]
+        if payload.get("error_message"):
+            body["error_message"] = payload["error_message"][:500]
+
+    return {k: v for k, v in body.items() if v is not None}
+
+
+# ---------------------------------------------------------------------------
+# Transport
+# ---------------------------------------------------------------------------
+
+def _send_http(data: bytes, transport_cfg: dict, log: logging.Logger) -> bool:
+    """POST the event as JSON over HTTP. Returns True on success."""
+    http = transport_cfg["http"]
+    req = urllib.request.Request(
+        http["url"], data=data,
+        headers={"Content-Type": "application/json"}, method="POST",
+    )
+    try:
+        urllib.request.urlopen(req, timeout=float(http["timeout_s"])).read()
+        log.debug("HTTP sent to %s", http["url"])
+        return True
+    except Exception as exc:
+        log.error("HTTP send failed: %s", exc)
+        print(f"[claude_hook] HTTP: {exc}", file=sys.stderr)
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Self-test
+# ---------------------------------------------------------------------------
+
+def _run_test(cfg: dict, log: logging.Logger) -> int:
+    """Send a synthetic __test__ event and report pass/fail with timing."""
+    t = cfg["transport"]
+    test_body = _build_body("__test__", {
+        "session_id": "test",
+        "cwd":        str(Path.cwd()),
+        "tool_name":  "claudehub-hooks --test",
+    })
+    test_body["test"] = True
+    data = json.dumps(test_body).encode("utf-8")
+
+    results: list[str] = []
+    ok = True
+
+    if t["http"]["enabled"]:
+        url = t["http"]["url"]
+        t0 = time.monotonic()
+        success = _send_http(data, t, log)
+        ms = int((time.monotonic() - t0) * 1000)
+        status = "OK" if success else "FAIL"
+        results.append(f"  HTTP  {url:<40} {status}  {ms}ms")
+        if not success:
+            ok = False
+
+    if not results:
+        results.append("  (no transports enabled)")
+        ok = False
+
+    print("claude_hook transport test")
+    print(f"  event:  __test__")
+    print(f"  host:   {socket.gethostname()}")
+    for line in results:
+        print(line)
+    print(f"\n{'PASS' if ok else 'FAIL'}")
+    return 0 if ok else 1
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main() -> int:
+    """Main dispatcher — invoked by Claude Code hooks."""
+    cfg = load_config()
+    log = _setup_logging(cfg)
+
+    if len(sys.argv) > 1 and sys.argv[1] == "--test":
+        return _run_test(cfg, log)
+
+    label = sys.argv[1] if len(sys.argv) > 1 else "Unknown"
+
+    raw = sys.stdin.read() if not sys.stdin.isatty() else ""
+    try:
+        payload = json.loads(raw) if raw.strip() else {}
+    except (ValueError, TypeError):
+        payload = {}
+
+    body = _build_body(label, payload)
+    data = json.dumps(body).encode("utf-8")
+
+    files_note = f" files={body['files']}" if body.get("files") else ""
+    log.info("event=%s session=%s host=%s%s",
+             label, body.get("session_id", ""), body.get("host", ""), files_note)
+    if label == "StopFailure" and body.get("error_type"):
+        log.warning("StopFailure error_type=%s: %s",
+                    body["error_type"], body.get("error_message", ""))
+
+    t = cfg["transport"]
+    if t["http"]["enabled"]:
+        _send_http(data, t, log)
+
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        code = main()
+    except Exception as exc:
+        try:
+            logging.getLogger("claude_hook").critical("unexpected: %s", exc)
+        except Exception:
+            pass
+        print(f"[claude_hook] unexpected: {exc}", file=sys.stderr)
+        code = 0   # never block the harness
+    sys.exit(code)

claudehub_hooks-0.1.0/src/claudehub_hooks.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: claudehub-hooks
+Version: 0.1.0
+Summary: Claude Code hook dispatcher — forwards lifecycle events to Claude Monitor
+Author-email: Pandiyaraj Karuppasamy <pandiyarajk@live.com>
+License-Expression: MIT
+Keywords: claude,claude-code,claudehub,hooks,monitor,dispatcher
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# claudehub-hooks
+
+Pip-installable [Claude Code](https://docs.anthropic.com/en/docs/claude-code) hook dispatcher.
+Install once, then wire any repository to a Claude Monitor HTTP
+endpoint in one command — no manual script copying or JSON editing.
+
+Events flow: **Claude Code → claudehub-hooks dispatcher → Claude Monitor**.
+
+## Install
+
+```bash
+pip install claudehub-hooks
+```
+
+Requires Python 3.10+. No third-party runtime dependencies (stdlib only).
+
+## Quick start
+
+```bash
+claudehub-hooks install
+```
+
+Run from a repository root (or pass `--repo`). The command is **idempotent** — safe to re-run.
+
+```bash
+claudehub-hooks install --repo /path/to/repo
+claudehub-hooks install --url http://192.168.1.50:7070/event
+claudehub-hooks install --dry-run
+```
+
+### What it writes
+
+| File | Purpose |
+|------|---------|
+| `.claude/hooks/claude_hook.py` | Hook dispatcher (invoked by Claude Code) |
+| `.claude/hooks/monitor_config.json` | Transport config with the monitor URL |
+| `.claude/settings.json` | Nine hook entries merged in (existing entries kept) |
+
+## Change the monitor URL
+
+Edit `.claude/hooks/monitor_config.json` in the repo:
+
+```json
+{
+  "transport": {
+    "http": { "url": "http://192.168.1.50:7070/event" }
+  }
+}
+```
+
+Or set an environment variable (overrides the file):
+
+```bash
+export CLAUDE_HUB_URL="http://192.168.1.50:7070/event"
+```
+
+On Windows (persistent):
+
+```bat
+setx CLAUDE_HUB_URL "http://192.168.1.50:7070/event"
+```
+
+## Test connectivity
+
+```bash
+python .claude/hooks/claude_hook.py --test
+```
+
+## Hooks installed
+
+| Event | Trigger |
+|-------|---------|
+| `SessionStart` | Claude session begins |
+| `UserPromptSubmit` | User sends a message |
+| `Notification` | Claude needs input |
+| `PostToolUse` | File read/edited (Edit · Write · NotebookEdit · MultiEdit · Read) |
+| `Stop` | Turn completes |
+| `StopFailure` | API error |
+| `PermissionRequest` | Allow/deny dialog shown |
+| `PermissionDenied` | User denied a tool |
+| `PreToolUse` | Tool about to run (resolves permission) |
+
+## Configuration
+
+| Variable | Default | Meaning |
+|----------|---------|---------|
+| `CLAUDE_HUB_URL` | `http://127.0.0.1:7070/event` | Monitor endpoint |
+| `CLAUDE_HUB_TIMEOUT` | `2.0` | HTTP timeout (seconds) |
+| `CLAUDE_HUB_HTTP_ENABLED` | `true` | Set to `false` to silence all hooks |
+| `CLAUDE_HOOK_LOG_LEVEL` | `INFO` | Dispatcher log level |
+| `CLAUDE_HOOK_LOG_FILE` | `~/.claude/claude_hook.log` | Override log path |
+| `CLAUDE_HUB_CONFIG` | — | Path to a `monitor_config.json` override |
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+**Author:** Pandiyaraj Karuppasamy · pandiyarajk@live.com

claudehub_hooks-0.1.0/src/claudehub_hooks.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/claudehub_hooks/__init__.py
+src/claudehub_hooks/_settings.py
+src/claudehub_hooks/cli.py
+src/claudehub_hooks/hook.py
+src/claudehub_hooks.egg-info/PKG-INFO
+src/claudehub_hooks.egg-info/SOURCES.txt
+src/claudehub_hooks.egg-info/dependency_links.txt
+src/claudehub_hooks.egg-info/entry_points.txt
+src/claudehub_hooks.egg-info/top_level.txt

claudehub_hooks-0.1.0/src/claudehub_hooks.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

claudehub_hooks-0.1.0/src/claudehub_hooks.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+claudehub-hooks = claudehub_hooks.cli:main

claudehub_hooks-0.1.0/src/claudehub_hooks.egg-info/top_level.txt

@@ -0,0 +1 @@
+claudehub_hooks