methodproof 0.5.0__tar.gz → 0.5.2__tar.gz

{methodproof-0.5.0 → methodproof-0.5.2}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.5.1] — 2026-04-06
+
+### Fixed
+- macOS daemon segfault: replaced `os.fork()` with `subprocess.Popen()` — CoreFoundation crash after fork killed all capture agents, producing 0 events
+- Hook type mismatches: `task_created`→`task_start`, `task_completed`→`task_end`, added required `tool` field to all hook metadata
+- Unmapped hook events dropped instead of sent as invalid `claude_code_event` type (rejected entire batch)
+- Daemon output logged to `~/.methodproof/daemon.log` instead of `/dev/null`
+- ~20 silent `except Exception: pass` blocks replaced with structured logging across bridge, hooks, live streaming, sync, keychain, MCP, and proxy
+
+### Changed
+- Daemon health check on startup — immediate error if daemon exits
+- Extension status check shows actual error on failure
+
 ## [0.3.4] — 2026-04-05
 
 ### Added

{methodproof-0.5.0 → methodproof-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.5.0
+Version: 0.5.2
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE

methodproof-0.5.2/methodproof/_daemon.py

@@ -0,0 +1,114 @@
+"""Daemon process for methodproof capture — spawned by cmd_start via subprocess.
+
+Uses subprocess.Popen (fork+exec) instead of os.fork() to avoid macOS
+CoreFoundation segfaults when forking a multi-threaded Python 3.12+ process.
+"""
+
+import signal
+import sys
+import threading
+import time
+
+from methodproof import config, store, graph
+from methodproof.agents import base
+
+PIDFILE = config.DIR / "methodproof.pid"
+
+
+def main() -> None:
+    sid = sys.argv[1]
+    watch_dir = sys.argv[2]
+
+    cfg = config.load()
+    capture = cfg.get("capture", {})
+    live_url = cfg.get("_live_url", "")
+
+    # Clean up transient key
+    if "_live_url" in cfg:
+        del cfg["_live_url"]
+        config.save(cfg)
+
+    base.init(sid, live=bool(live_url))
+
+    # Environment profile (was done pre-fork in old code, now done in daemon)
+    if capture.get("environment_analysis", True):
+        try:
+            from methodproof.analysis import scan_environment
+            env_profile = scan_environment(watch_dir)
+            base.emit("environment_profile", env_profile)
+        except Exception as exc:
+            base.log("warning", "environment_scan.failed", error=str(exc))
+
+    stop_event = threading.Event()
+    threads: list[threading.Thread] = []
+
+    files_enabled = (
+        capture.get("file_changes", True)
+        or capture.get("git_diffs", True)
+        or capture.get("git_commits", True)
+    )
+    if files_enabled:
+        from methodproof.agents import watcher
+        threads.append(threading.Thread(
+            target=watcher.start, args=(watch_dir, stop_event), daemon=True,
+        ))
+
+    if capture.get("terminal_commands", True) or capture.get("test_results", True):
+        from methodproof.agents import terminal
+        threads.append(threading.Thread(
+            target=terminal.start, args=(stop_event,), daemon=True,
+        ))
+
+    if capture.get("browser", True):
+        from methodproof import bridge
+        threads.append(threading.Thread(
+            target=bridge.start,
+            args=(sid, stop_event, 9877,
+                  cfg.get("token", ""), cfg.get("api_url", ""), cfg.get("e2e_key", "")),
+            daemon=True,
+        ))
+
+    if capture.get("music", True):
+        from methodproof.agents import music
+        threads.append(threading.Thread(
+            target=music.start, args=(stop_event,), daemon=True,
+        ))
+
+    def _shutdown(sig_num: int, frame: object) -> None:
+        stop_event.set()
+        try:
+            if live_url:
+                from methodproof import live as live_mod
+                live_mod.stop()
+            base.flush()
+            store.complete_session(sid)
+            graph.build(sid)
+        except Exception as exc:
+            base.log("error", "daemon.shutdown_cleanup_failed", error=str(exc))
+        try:
+            cfg_now = config.load()
+            cfg_now["active_session"] = None
+            config.save(cfg_now)
+        except Exception as exc:
+            base.log("error", "daemon.config_cleanup_failed", error=str(exc))
+        PIDFILE.unlink(missing_ok=True)
+        sys.exit(0)
+
+    for t in threads:
+        t.start()
+    signal.signal(signal.SIGINT, _shutdown)
+    signal.signal(signal.SIGTERM, _shutdown)
+
+    base.log("info", "daemon.started", session_id=sid, watch_dir=watch_dir, agents=len(threads))
+
+    try:
+        while not stop_event.is_set():
+            time.sleep(5)
+            base.flush()
+    except Exception as exc:
+        base.log("error", "daemon.loop_crashed", error=str(exc))
+        _shutdown(0, None)
+
+
+if __name__ == "__main__":
+    main()

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/agents/music.py

@@ -39,7 +39,8 @@ def _get_now_playing_macos() -> dict[str, str] | None:
         if len(parts) != 3 or not parts[0]:
             return None
         return {"track": parts[0], "artist": parts[1], "player": parts[2]}
-    except Exception:
+    except Exception as exc:
+        base.log("debug", "music.macos_poll_failed", error=str(exc))
         return None
 
 
@@ -58,7 +59,8 @@ def _get_now_playing_linux() -> dict[str, str] | None:
         return {"track": parts[1], "artist": parts[0], "player": player_map.get(parts[2].lower(), "unknown")}
     except FileNotFoundError:
         return None
-    except Exception:
+    except Exception as exc:
+        base.log("debug", "music.linux_poll_failed", error=str(exc))
         return None
 
 

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/bridge.py

@@ -73,7 +73,9 @@ def generate_pair_token(session_id: str, api_token: str, api_base: str, e2e_key:
 
 class _Handler(BaseHTTPRequestHandler):
     def log_message(self, fmt: str, *args: Any) -> None:
-        pass
+        # Log errors (4xx/5xx) to structured log; suppress normal request chatter
+        if args and str(args[0]).startswith(("4", "5")):
+            base.log("warning", "bridge.http_error", status=args[0], path=self.path)
 
     def do_GET(self) -> None:
         if self.path == "/session":

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/cli.py

@@ -907,8 +907,8 @@ def cmd_start(args: argparse.Namespace) -> None:
             from methodproof.sync import _request
             anchor = _request("POST", f"/sessions/{sid}/anchor", cfg["api_url"], cfg["token"])
             store.update_anchor(sid, anchor["anchor_ts"], anchor["signature"])
-        except Exception:
-            pass  # offline — no anchor, lower trust score
+        except Exception as exc:
+            print(f"Anchor: skipped ({exc})")
 
     from methodproof.agents import base
     live_ok = False
@@ -950,21 +950,68 @@ def cmd_start(args: argparse.Namespace) -> None:
             print("Journal mode ON for this session (full content capture).")
         config.save(cfg)
 
-    base.init(sid, live=bool(live_url))
+    # Save live_url for daemon subprocess to pick up
+    if live_url:
+        cfg["_live_url"] = live_url
+        config.save(cfg)
 
+    active = [k for k, v in capture.items() if v]
+    print(f"\n{_banner()}")
+    print(f"Recording: {sid[:8]}")
+    print(f"Watching:  {watch_dir}")
+    if repo_url:
+        print(f"Repo:      {repo_url}")
+    print(f"Capture:   {', '.join(active)}")
+    if capture.get("browser", True):
+        print(f"Bridge:    http://localhost:9877")
+    if live_url:
+        print(f"Live:      {live_url}")
+
+    # Daemonize: spawn a subprocess (safe on macOS — avoids CoreFoundation segfault from os.fork)
+    if sys.platform != "win32":
+        import subprocess as _sp
+        daemon_log = config.DIR / "daemon.log"
+        log_fh = open(daemon_log, "a")
+        proc = _sp.Popen(
+            [sys.executable, "-m", "methodproof._daemon", sid, watch_dir],
+            start_new_session=True,
+            stdout=log_fh, stderr=log_fh, stdin=_sp.DEVNULL,
+        )
+        PIDFILE.write_text(str(proc.pid))
+        # Verify daemon is alive after brief startup
+        time.sleep(1)
+        if proc.poll() is not None:
+            print(f"ERROR: Daemon exited immediately (code {proc.returncode}). Check {daemon_log}")
+            PIDFILE.unlink(missing_ok=True)
+            sys.exit(1)
+        # Check extension auto-discovery (extension polls every ~6s)
+        if capture.get("browser", True):
+            import urllib.request as _ur
+            time.sleep(7)
+            try:
+                with _ur.urlopen("http://127.0.0.1:9877/extension-status", timeout=2) as resp:
+                    ext_data = json.loads(resp.read())
+                if ext_data.get("paired"):
+                    print("Extension: connected")
+                else:
+                    print("Extension: not detected — run `mp extension pair` or install from store")
+            except Exception as exc:
+                print(f"Extension: not detected ({exc})")
+        print("Run `mp stop` to finish.")
+        return
+
+    # Windows: foreground mode (no subprocess daemonization)
+    from methodproof.agents import base as _base
+    _base.init(sid, live=bool(live_url))
     if capture.get("environment_analysis", True):
-        from methodproof.analysis import scan_environment
         try:
+            from methodproof.analysis import scan_environment
             env_profile = scan_environment(watch_dir)
-            base.emit("environment_profile", env_profile)
-        except Exception:
-            base.log("warning", "environment_scan.failed")
-
+            _base.emit("environment_profile", env_profile)
+        except Exception as exc:
+            _base.log("warning", "environment_scan.failed", error=str(exc))
     stop_event = threading.Event()
-
     threads: list[threading.Thread] = []
-
-    # File watcher — if any file/git category is enabled
     files_enabled = (
         capture.get("file_changes", True)
         or capture.get("git_diffs", True)
@@ -973,100 +1020,39 @@ def cmd_start(args: argparse.Namespace) -> None:
     if files_enabled:
         from methodproof.agents import watcher
         threads.append(threading.Thread(target=watcher.start, args=(watch_dir, stop_event), daemon=True))
-
-    # Terminal monitor — if terminal or test categories enabled
     if capture.get("terminal_commands", True) or capture.get("test_results", True):
         from methodproof.agents import terminal
         threads.append(threading.Thread(target=terminal.start, args=(stop_event,), daemon=True))
-
-    # Bridge — if browser category enabled
     if capture.get("browser", True):
         from methodproof import bridge
         threads.append(threading.Thread(target=bridge.start, args=(
             sid, stop_event, 9877,
             cfg.get("token", ""), cfg.get("api_url", ""), cfg.get("e2e_key", ""),
         ), daemon=True))
-
-    # Music — if music category enabled
     if capture.get("music", True):
         from methodproof.agents import music
         threads.append(threading.Thread(target=music.start, args=(stop_event,), daemon=True))
 
-    active = [k for k, v in capture.items() if v]
-    print(f"\n{_banner()}")
-    print(f"Recording: {sid[:8]}")
-    print(f"Watching:  {watch_dir}")
-    if repo_url:
-        print(f"Repo:      {repo_url}")
-    print(f"Capture:   {', '.join(active)}")
-    if capture.get("browser", True):
-        print(f"Bridge:    http://localhost:9877")
-    if live_url:
-        print(f"Live:      {live_url}")
-
     def _shutdown(sig: int, frame: object) -> None:
         stop_event.set()
         try:
             if live_url:
                 from methodproof import live as live_mod
                 live_mod.stop()
-            base.flush()
+            _base.flush()
             store.complete_session(sid)
             graph.build(sid)
-        except Exception:
-            pass
+        except Exception as exc:
+            _base.log("error", "shutdown.cleanup_failed", error=str(exc))
         try:
             cfg_now = config.load()
             cfg_now["active_session"] = None
             config.save(cfg_now)
-        except Exception:
-            pass
+        except Exception as exc:
+            _base.log("error", "shutdown.config_cleanup_failed", error=str(exc))
         PIDFILE.unlink(missing_ok=True)
         sys.exit(0)
 
-    # Daemonize: fork into background so the terminal is free
-    if sys.platform != "win32":
-        child = os.fork()
-        if child > 0:
-            # Parent: write child PID and exit
-            PIDFILE.write_text(str(child))
-            # Brief pause for extension auto-discovery (extension polls every ~6s in dev)
-            if capture.get("browser", True):
-                import urllib.request as _ur
-                time.sleep(8)
-                try:
-                    with _ur.urlopen("http://127.0.0.1:9877/extension-status", timeout=2) as resp:
-                        ext_data = json.loads(resp.read())
-                    if ext_data.get("paired"):
-                        print(f"Extension: connected")
-                    else:
-                        print(f"Extension: not detected — run `mp extension pair` or install from store")
-                except Exception:
-                    print(f"Extension: not detected")
-            print("Run `mp stop` to finish.")
-            return
-        # Child: detach and run in background
-        os.setsid()
-        # Redirect stdio to /dev/null so writes don't fail after terminal closes
-        devnull = os.open(os.devnull, os.O_RDWR)
-        os.dup2(devnull, 0)
-        os.dup2(devnull, 1)
-        os.dup2(devnull, 2)
-        os.close(devnull)
-        store.reset_connection()
-        for t in threads:
-            t.start()
-        signal.signal(signal.SIGINT, _shutdown)
-        signal.signal(signal.SIGTERM, _shutdown)
-        try:
-            while not stop_event.is_set():
-                time.sleep(5)
-                base.flush()
-        except Exception:
-            _shutdown(0, None)
-        return
-
-    # Windows: foreground mode (no fork)
     for t in threads:
         t.start()
     signal.signal(signal.SIGINT, _shutdown)
@@ -1077,7 +1063,7 @@ def cmd_start(args: argparse.Namespace) -> None:
             stopfile.unlink(missing_ok=True)
             _shutdown(0, None)
         time.sleep(5)
-        base.flush()
+        _base.flush()
 
 
 def cmd_stop(args: argparse.Namespace) -> None:
@@ -1160,10 +1146,16 @@ def cmd_login(args: argparse.Namespace) -> None:
     result = _request("POST", "/auth/cli/start", api, "")
     code = result["code"]
     auth_url = result["auth_url"]
+    user_code = result.get("user_code", "")
+    verification_url = result.get("verification_url", "")
 
     print(f"\nOpening browser to sign in...\n")
     print(f"  {auth_url}\n")
-    print("If the browser doesn't open, copy the URL above.\n")
+    if user_code and verification_url:
+        print(f"Can't open a browser? Visit {verification_url} and enter:\n")
+        print(f"  {user_code}\n")
+    else:
+        print("If the browser doesn't open, copy the URL above.\n")
     webbrowser.open(auth_url)
 
     # Poll until approved or expired

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/graph.py

@@ -87,8 +87,9 @@ def build(session_id: str) -> dict[str, int]:
                  time.time(), 0, json.dumps(outcomes)),
             )
             stats["outcomes"] = 1
-    except Exception:
-        pass
+    except Exception as exc:
+        from methodproof.agents.base import log
+        log("warning", "graph.outcomes_failed", session_id=session_id, error=str(exc))
 
     db.commit()
     return stats

methodproof-0.5.2/methodproof/hooks/claude_code.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""MethodProof hook for Claude Code — cross-platform Python equivalent of claude_code.sh.
+
+Receives JSON on stdin. Posts to local bridge. Fails silently.
+Uses only stdlib — no jq, no curl dependency.
+"""
+
+import json
+import sys
+import time
+import urllib.request
+
+try:
+    from methodproof.analysis import analyze_prompt, compose_summary
+except ImportError:
+    analyze_prompt = lambda _: {}
+    compose_summary = lambda _: ""
+
+def _build_prompt_meta(text: str) -> dict:
+    sa = analyze_prompt(text)
+    sa["prompt_length"] = len(text)
+    sa["prompt_summary"] = compose_summary(sa)
+    return sa
+
+
+_TYPE_MAP = {
+    "UserPromptSubmit": "user_prompt",
+    "PreToolUse": "tool_call",
+    "PostToolUse": "tool_result",
+    "SubagentStart": "agent_launch",
+    "SubagentStop": "agent_complete",
+    "TaskCreated": "task_start",
+    "TaskCompleted": "task_end",
+    "SessionStart": "claude_session_start",
+}
+
+_TOOL = "claude_code"
+
+_META_EXTRACTORS = {
+    "UserPromptSubmit": lambda d: {
+        "tool": _TOOL, "prompt_preview": _build_prompt_meta(d.get("prompt") or "").get("prompt_summary", ""),
+        "prompt_length": len(d.get("prompt") or ""),
+    },
+    "PreToolUse": lambda d: {"tool": _TOOL, "tool_name": d.get("tool_name", "unknown")},
+    "PostToolUse": lambda d: {"tool": _TOOL, "tool_name": d.get("tool_name", "unknown"), "success": True},
+    "SubagentStart": lambda d: {"tool": _TOOL, "agent_type": d.get("agent_type", "unknown"), "agent_id": d.get("agent_id", "")},
+    "SubagentStop": lambda d: {"tool": _TOOL, "agent_type": d.get("agent_type", "unknown"), "agent_id": d.get("agent_id", "")},
+    "TaskCreated": lambda d: {"tool": _TOOL, "task_id": d.get("task_id", ""), "subject": d.get("subject", "")},
+    "TaskCompleted": lambda d: {"tool": _TOOL, "task_id": d.get("task_id", "")},
+    "SessionStart": lambda d: {"tool": _TOOL, "session_id": d.get("session_id", ""), "cwd": d.get("cwd", "")},
+}
+
+
+def main() -> None:
+    try:
+        data = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        return
+
+    event = data.get("hook_event_name", "unknown")
+    etype = _TYPE_MAP.get(event)
+    if not etype:
+        return  # Unmapped hook event — drop rather than send invalid type
+    extractor = _META_EXTRACTORS.get(event)
+    meta = extractor(data) if extractor else {"tool": _TOOL}
+    ts = time.time()
+
+    payload = json.dumps({"events": [{"type": etype, "timestamp": ts, "metadata": meta}]}).encode()
+    req = urllib.request.Request(
+        "http://localhost:9877/events", data=payload,
+        headers={"Content-Type": "application/json"}, method="POST",
+    )
+    try:
+        urllib.request.urlopen(req, timeout=1)
+    except Exception as exc:
+        import pathlib
+        log = pathlib.Path.home() / ".methodproof" / "hook_errors.log"
+        try:
+            with open(log, "a") as f:
+                f.write(f"{time.time():.0f} hook.post_failed type={etype} error={exc}\n")
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    main()

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/keychain.py

@@ -32,8 +32,8 @@ def load_secret(account_id: str) -> bytes | None:
         val = keyring.get_password(_SERVICE, account_id)
         if val:
             return bytes.fromhex(val)
-    except Exception:
-        pass
+    except Exception as exc:
+        sys.stderr.write(f"keychain.load_failed account={account_id} error={exc}\n")
     return _load_file()
 
 
@@ -42,8 +42,8 @@ def delete_secret(account_id: str) -> None:
     try:
         import keyring
         keyring.delete_password(_SERVICE, account_id)
-    except Exception:
-        pass
+    except Exception as exc:
+        sys.stderr.write(f"keychain.delete_failed account={account_id} error={exc}\n")
     path = _fallback_path()
     if path.exists():
         path.unlink()

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/live.py

@@ -95,7 +95,8 @@ def send(event: dict[str, Any]) -> None:
     try:
         _send_queue.put_nowait(json.dumps(event, default=str))
     except queue.Full:
-        pass
+        from methodproof.agents.base import log
+        log("warning", "live.queue_full", dropped_type=event.get("type", "?"))
 
 
 def stop() -> None:
@@ -106,8 +107,9 @@ def stop() -> None:
     if _ws:
         try:
             _ws.close()
-        except Exception:
-            pass
+        except Exception as exc:
+            from methodproof.agents.base import log
+            log("warning", "live.close_failed", error=str(exc))
         _ws = None
 
 

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/mcp.py

@@ -30,8 +30,8 @@ def _emit(event_type: str, metadata: dict[str, Any]) -> None:
             headers={"Content-Type": "application/json"}, method="POST",
         )
         urllib.request.urlopen(req, timeout=2)
-    except Exception:
-        pass
+    except Exception as exc:
+        sys.stderr.write(f"mcp.bridge_post_failed type={event_type} error={exc}\n")
 
 
 def serve() -> None:

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/proxy_daemon.py

@@ -35,13 +35,13 @@ _STRIP_HEADERS = {"authorization", "x-api-key", "api-key", "x-goog-api-key"}
 
 
 def _post_event(event_type: str, metadata: dict) -> None:
-    """Post event to bridge. Fail silently."""
+    """Post event to bridge. Logs on failure."""
     body = json.dumps({"events": [{"type": event_type, "timestamp": time.time(), "metadata": metadata}]}).encode()
     req = urllib.request.Request(BRIDGE_URL, data=body, headers={"Content-Type": "application/json"})
     try:
         urllib.request.urlopen(req, timeout=1)
-    except Exception:
-        pass
+    except Exception as exc:
+        sys.stderr.write(f"proxy.bridge_post_failed type={event_type} error={exc}\n")
 
 
 def _is_ai_domain(domain: str) -> bool:
@@ -68,8 +68,8 @@ def _decode_via_binary(provider: str, direction: str, body: dict, latency_ms: fl
         )
         if result.returncode == 0 and result.stdout.strip():
             return json.loads(result.stdout)
-    except Exception:
-        pass
+    except Exception as exc:
+        sys.stderr.write(f"proxy.decoder_failed provider={provider} dir={direction} error={exc}\n")
     return None
 
 
@@ -83,7 +83,8 @@ def _match_provider(domain: str, path: str) -> str | None:
         )
         name = result.stdout.strip()
         return name if name and name != "null" else None
-    except Exception:
+    except Exception as exc:
+        sys.stderr.write(f"proxy.match_failed domain={domain} path={path} error={exc}\n")
         return None
 
 

{methodproof-0.5.0 → methodproof-0.5.2}/methodproof/sync.py

@@ -42,7 +42,9 @@ def _refresh_token(api_url: str, refresh: str) -> tuple[str, str] | None:
     try:
         result = _raw_request("POST", f"{api_url}/auth/refresh", "", {"refresh_token": refresh})
         return result["access_token"], result["refresh_token"]
-    except Exception:
+    except Exception as exc:
+        from methodproof.agents.base import log
+        log("warning", "sync.refresh_token_failed", error=str(exc))
         return None
 
 
@@ -69,8 +71,8 @@ def _request(
         if exc.fp:
             try:
                 detail = json.loads(exc.read()).get("detail", "")
-            except Exception:
-                pass
+            except Exception as parse_err:
+                detail = f"(response unreadable: {parse_err})"
         raise SystemExit(f"API error {exc.code}: {detail}") from None
 
 

{methodproof-0.5.0 → methodproof-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.5.0"
+version = "0.5.2"
 description = "See how you code. Capture and visualize your engineering process."
 requires-python = ">=3.11"
 dependencies = ["watchdog>=4.0", "websocket-client>=1.7", "cryptography>=43.0", "keyring>=25.0"]