methodproof 0.4.4__tar.gz → 0.5.0__tar.gz

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

@@ -1,18 +1,16 @@
 Metadata-Version: 2.4
 Name: methodproof
-Version: 0.4.4
+Version: 0.5.0
 Summary: See how you code. Capture and visualize your engineering process.
 License-Expression: Apache-2.0
 License-File: LICENSE
 Requires-Python: >=3.11
+Requires-Dist: cryptography>=43.0
+Requires-Dist: keyring>=25.0
 Requires-Dist: watchdog>=4.0
 Requires-Dist: websocket-client>=1.7
-Provides-Extra: e2e
-Requires-Dist: cryptography>=43.0; extra == 'e2e'
 Provides-Extra: proxy
 Requires-Dist: mitmproxy>=10.0; extra == 'proxy'
-Provides-Extra: signing
-Requires-Dist: cryptography>=43.0; extra == 'signing'
 Description-Content-Type: text/markdown
 
 <p align="center">

{methodproof-0.4.4 → methodproof-0.5.0}/methodproof/__init__.py

@@ -1,3 +1,3 @@
 """MethodProof — see how you code."""
 
-__version__ = "0.4.4"
+__version__ = "0.5.0"

{methodproof-0.4.4 → methodproof-0.5.0}/methodproof/agents/base.py

@@ -19,6 +19,8 @@ _buffer: list[dict[str, Any]] = []
 _FLUSH_SIZE = 50
 _MAX_RETRIES = 3
 _prev_hash = "genesis"
+_account_id = ""
+_journal_mode = False
 
 # Maps event types to the capture category that gates them
 _EVENT_GATES: dict[str, str] = {
@@ -74,21 +76,33 @@ _FIELD_GATES: dict[str, list[tuple[str, str]]] = {
     "code_capture": [("file_edit", "diff"), ("git_commit", "diff")],
 }
 
-_journal_mode = False
+
+def _load_encryption_key(cfg: dict) -> bytes | None:
+    """Load db_key from keychain (preferred) or legacy e2e_key config."""
+    account_id = cfg.get("account_id", "")
+    if account_id and cfg.get("master_key_fingerprint"):
+        from methodproof.keychain import load_secret
+        from methodproof.kdf import derive_master, derive_db_key
+        master_entropy = load_secret(account_id)
+        if master_entropy:
+            master = derive_master(master_entropy)
+            return derive_db_key(master, account_id)
+    raw = cfg.get("e2e_key", "")
+    return bytes.fromhex(raw) if raw else None
 
 
 def init(session_id: str, live: bool = False) -> None:
-    global _session_id, _initialized, _e2e_key, _capture, _live_mode, _prev_hash, _journal_mode
+    global _session_id, _initialized, _e2e_key, _capture, _live_mode, _prev_hash, _journal_mode, _account_id
     _session_id = session_id
     _initialized = True
     _live_mode = live
     _prev_hash = "genesis"
     from methodproof import config
     cfg = config.load()
-    raw = cfg.get("e2e_key", "")
-    _e2e_key = bytes.fromhex(raw) if raw else None
+    _e2e_key = _load_encryption_key(cfg)
     _capture = cfg.get("capture", {})
     _journal_mode = cfg.get("journal_mode", False)
+    _account_id = cfg.get("account_id", "")
 
 
 def log(level: str, event: str, **kw: object) -> None:
@@ -133,7 +147,7 @@ def emit(event_type: str, metadata: dict[str, Any]) -> None:
         entry["metadata"] = encrypt_metadata(dict(entry["metadata"]), _e2e_key)
     global _prev_hash
     from methodproof.integrity import compute_event_hash
-    entry["_chain_hash"] = compute_event_hash(entry, _prev_hash)
+    entry["_chain_hash"] = compute_event_hash(entry, _prev_hash, _account_id)
     _prev_hash = entry["_chain_hash"]
     if _live_mode:
         from methodproof import live as live_mod

methodproof-0.5.0/methodproof/binding.py

@@ -0,0 +1,28 @@
+"""Session binding — HMAC ties sessions to account + device."""
+
+import hashlib
+import hmac
+import os
+import platform
+import sys
+import time as _time
+
+
+def compute_binding(bind_key: bytes, session_id: str, account_id: str,
+                    device_id: str, created_at: float) -> str:
+    """HMAC-SHA256 binding signature for a session."""
+    msg = f"{session_id}:{account_id}:{device_id}:{created_at}".encode()
+    return hmac.new(bind_key, msg, hashlib.sha256).hexdigest()
+
+
+def compute_device_id() -> str:
+    """Deterministic device fingerprint — hash of stable machine attributes."""
+    parts = [
+        platform.node(),
+        platform.system(),
+        platform.machine(),
+        platform.python_version(),
+        _time.tzname[0],
+        str(os.cpu_count()),
+    ]
+    return hashlib.sha256(":".join(parts).encode()).hexdigest()[:16]

methodproof-0.5.0/methodproof/bip39.py

@@ -0,0 +1,37 @@
+"""BIP39 mnemonic encoding — 128-bit entropy to 12-word recovery phrase."""
+
+import hashlib
+
+
+def entropy_to_phrase(entropy: bytes) -> str:
+    """Encode 16 bytes (128 bits) as 12 BIP39 words with checksum."""
+    from methodproof.wordlist import WORDS
+    if len(entropy) != 16:
+        raise ValueError("Expected 16 bytes of entropy")
+    checksum = hashlib.sha256(entropy).digest()[0] >> 4  # 4 bits
+    bits = int.from_bytes(entropy) << 4 | checksum  # 132 bits
+    words = []
+    for _ in range(12):
+        words.append(WORDS[bits & 0x7FF])
+        bits >>= 11
+    return " ".join(reversed(words))
+
+
+def phrase_to_entropy(phrase: str) -> bytes:
+    """Decode 12 BIP39 words back to 16 bytes of entropy."""
+    from methodproof.wordlist import WORDS
+    word_list = phrase.strip().lower().split()
+    if len(word_list) != 12:
+        raise ValueError("Expected 12 words")
+    index = {w: i for i, w in enumerate(WORDS)}
+    bits = 0
+    for word in word_list:
+        if word not in index:
+            raise ValueError(f"Unknown word: {word}")
+        bits = (bits << 11) | index[word]
+    checksum = bits & 0xF
+    entropy = (bits >> 4).to_bytes(16)
+    expected = hashlib.sha256(entropy).digest()[0] >> 4
+    if checksum != expected:
+        raise ValueError("Invalid checksum")
+    return entropy

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

@@ -89,7 +89,7 @@ def _print_intro() -> None:
     print(f"    {D}See how you code. Prove how you build.{R}")
     print(f"\n  {bar}\n")
     print(f"   ┌────────────────────────────────────────────────┐")
-    print(f"   │  {Y}SHARE{R}     push · publish · live stream        │")
+    print(f"   │  {Y}SHARE{R}     push · publish · anonymous · live   │")
     print(f"   ├────────────────────────────────────────────────┤")
     print(f"   │  {C}GRAPH{R}     knowledge graph · moments · edges   │")
     print(f"   ├────────────────────────────────────────────────┤")
@@ -101,6 +101,7 @@ def _print_intro() -> None:
     print(f"   {D}3.{R} {G}mp stop{R}        build your process graph")
     print(f"   {D}4.{R} {G}mp push{R}        upload to your profile")
     print()
+    print(f"   {D}Publish anonymously (Pro) or contribute to research.{R}")
     print(f"   {D}All data stays local until you push.{R}\n")
 
 
@@ -110,7 +111,7 @@ def _print_intro_plain() -> None:
     print("    See how you code. Prove how you build.")
     print("\n  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n")
     print("   ┌────────────────────────────────────────────────┐")
-    print("   │  SHARE     push · publish · live stream        │")
+    print("   │  SHARE     push · publish · anonymous · live   │")
     print("   ├────────────────────────────────────────────────┤")
     print("   │  GRAPH     knowledge graph · moments · edges   │")
     print("   ├────────────────────────────────────────────────┤")
@@ -122,6 +123,7 @@ def _print_intro_plain() -> None:
     print("   3. mp stop        build your process graph")
     print("   4. mp push        upload to your profile")
     print()
+    print("   Publish anonymously (Pro) or contribute to research.")
     print("   All data stays local until you push.\n")
 
 
@@ -453,6 +455,7 @@ def _print_commands() -> None:
     print(f"  {_W}SHARE{R}")
     print(f"    {_Y}mp push{R}  {_D}[id]{R}          Upload privately to your account")
     print(f"    {_Y}mp publish{R} {_D}[id]{R}        Make session public (redaction applied)")
+    print(f"    {_Y}mp publish --anonymous{R}  Public but identity hidden {_D}(Pro){R}")
     print(f"    {_Y}mp tag{R} {_D}<id> <tags>{R}     Tag a session")
     print()
     print(f"  {_W}EXTENSION{R}")
@@ -463,6 +466,8 @@ def _print_commands() -> None:
     print(f"  {_W}ACCOUNT{R}")
     print(f"    {_M}mp login{R}              Connect to platform (opens browser)")
     print(f"    {_M}mp consent{R}            Change capture, research, and redaction settings")
+    print(f"    {_M}mp lock{R}                Destroy local encryption key {_D}(reversible){R}")
+    print(f"    {_M}mp lock --purge{R}        Delete all local data {_D}(irreversible){R}")
     print(f"    {_M}mp reset{R}               Clear login and consent (keeps sessions)")
     print(f"    {_M}mp delete{R} {_D}<id>{R}        Delete a session and all its data")
     print(f"    {_M}mp update{R}              Update to the latest version")
@@ -487,6 +492,7 @@ def _print_commands_plain() -> None:
     print("  SHARE")
     print("    mp push  [id]         Upload privately to your account")
     print("    mp publish [id]       Make session public (redaction applied)")
+    print("    mp publish --anonymous  Public but identity hidden (Pro)")
     print("    mp tag <id> <tags>    Tag a session")
     print()
     print("  EXTENSION")
@@ -497,6 +503,8 @@ def _print_commands_plain() -> None:
     print("  ACCOUNT")
     print("    mp login              Connect to platform (opens browser)")
     print("    mp consent            Change capture, research, and redaction settings")
+    print("    mp lock               Destroy local encryption key (reversible)")
+    print("    mp lock --purge       Delete all local data (irreversible)")
     print("    mp reset              Clear login and consent (keeps sessions)")
     print("    mp delete <id>        Delete a session and all its data")
     print("    mp update             Update to the latest version")
@@ -605,6 +613,25 @@ def cmd_uninstall(args: argparse.Namespace) -> None:
     print("  Restart your shell to clear hooks.\n")
 
 
+def cmd_lock(args: argparse.Namespace) -> None:
+    """Destroy local key access. --purge deletes DB entirely."""
+    cfg = config.load()
+    account_id = cfg.get("account_id", "")
+    if not account_id:
+        print("No account linked. Nothing to lock.")
+        return
+    purge = getattr(args, "purge", False)
+    if not args.force:
+        action = "DELETE all local data" if purge else "lock encrypted fields"
+        answer = input(f"  {action}? [y/N]: ").strip().lower()
+        if answer not in ("y", "yes"):
+            print("  Cancelled.")
+            return
+    from methodproof.lock import lock
+    lock(account_id, purge=purge)
+    print("  Done.\n")
+
+
 def cmd_reset(args: argparse.Namespace) -> None:
     """Wipe login credentials and consent config. Sessions and hooks kept."""
     cfg = config.load()
@@ -690,6 +717,122 @@ def cmd_journal(args: argparse.Namespace) -> None:
         print("Usage: methodproof journal [on|off|status]")
 
 
+def _decode_jwt_claims(token: str) -> dict:
+    """Extract claims from JWT payload without verification (auth already done server-side)."""
+    import base64
+    parts = token.split(".")
+    if len(parts) != 3:
+        return {}
+    payload = parts[1] + "=" * (-len(parts[1]) % 4)  # pad base64
+    return json.loads(base64.urlsafe_b64decode(payload))
+
+
+def _require_auth(cfg: dict) -> str:
+    """Ensure valid auth. Returns account_id. Exits on failure."""
+    token = cfg.get("token", "")
+    if not token:
+        print("Login required. Run `mp login` first.")
+        sys.exit(1)
+    claims = _decode_jwt_claims(token)
+    account_id = claims.get("user_id", "")
+    if not account_id:
+        print("Invalid token. Run `mp login` to re-authenticate.")
+        sys.exit(1)
+    # Check expiry — attempt refresh if expired
+    exp = claims.get("exp", 0)
+    if exp and time.time() > exp:
+        from methodproof.sync import _refresh_token
+        pair = _refresh_token(cfg["api_url"], cfg.get("refresh_token", ""))
+        if pair:
+            cfg["token"], cfg["refresh_token"] = pair
+            cfg["last_auth_at"] = time.time()
+            cfg["account_id"] = account_id
+            config.save(cfg)
+            return account_id
+        # Offline grace — allow if last auth was within 24h
+        if time.time() - cfg.get("last_auth_at", 0) < 86400:
+            return account_id
+        print("Session expired. Run `mp login` to re-authenticate.")
+        sys.exit(1)
+    cfg["last_auth_at"] = time.time()
+    cfg["account_id"] = account_id
+    config.save(cfg)
+    return account_id
+
+
+def _setup_master_key(cfg: dict) -> None:
+    """Generate or recover master key on first login. Shows recovery phrase once."""
+    account_id = cfg.get("account_id", "")
+    if not account_id:
+        return
+    from methodproof.keychain import has_secret, store_secret, load_secret
+    if has_secret(account_id):
+        # Already set up — ensure fingerprint is in config
+        if not cfg.get("master_key_fingerprint"):
+            from methodproof.kdf import derive_master, derive_db_key
+            from methodproof.crypto import fingerprint
+            master = derive_master(load_secret(account_id))
+            cfg["master_key_fingerprint"] = fingerprint(derive_db_key(master, account_id))
+            config.save(cfg)
+        return
+
+    # Check if user has a recovery phrase (returning user, new device)
+    if cfg.get("master_key_fingerprint"):
+        _recover_master_key(cfg, account_id)
+        return
+
+    # First time — generate entropy, show recovery phrase
+    entropy = os.urandom(16)
+    from methodproof.bip39 import entropy_to_phrase
+    phrase = entropy_to_phrase(entropy)
+    store_secret(account_id, entropy)
+
+    from methodproof.kdf import derive_master, derive_db_key
+    from methodproof.crypto import fingerprint
+    master = derive_master(entropy)
+    cfg["master_key_fingerprint"] = fingerprint(derive_db_key(master, account_id))
+    config.save(cfg)
+
+    W = "\033[1;97m"
+    Y = "\033[93m"
+    D = "\033[90m"
+    R = _RESET
+    print(f"  ┌──────────────────────────────────────────────────┐")
+    print(f"  │  {W}RECOVERY PHRASE — WRITE THIS DOWN{R}               │")
+    print(f"  │                                                  │")
+    print(f"  │  {Y}{phrase}{R}")
+    print(f"  │                                                  │")
+    print(f"  │  {D}This is the only way to recover your data{R}      │")
+    print(f"  │  {D}on a new device. Store it somewhere safe.{R}      │")
+    print(f"  └──────────────────────────────────────────────────┘\n")
+
+    # Encrypt any existing plaintext events
+    db_key = derive_db_key(master, account_id)
+    from methodproof.migrate_db import migrate_encrypt
+    count = migrate_encrypt(db_key)
+    if count:
+        print(f"  Encrypted {count} existing events.\n")
+
+
+def _recover_master_key(cfg: dict, account_id: str) -> None:
+    """Prompt for recovery phrase to restore master key on new device."""
+    print("\n  Master key not found on this device.")
+    print("  Enter your 12-word recovery phrase to restore access.\n")
+    phrase = input("  Recovery phrase: ").strip()
+    if not phrase:
+        print("  Skipped. Encrypted session data will be inaccessible.")
+        return
+    from methodproof.bip39 import phrase_to_entropy
+    try:
+        entropy = phrase_to_entropy(phrase)
+    except ValueError as e:
+        print(f"  Invalid phrase: {e}")
+        return
+    from methodproof.keychain import store_secret
+    store_secret(account_id, entropy)
+    print("  Master key restored.\n")
+
+
 def _is_daemon_alive() -> bool:
     """Check if the recording daemon is still running."""
     if not PIDFILE.exists():
@@ -723,6 +866,8 @@ def cmd_start(args: argparse.Namespace) -> None:
         print("Run `methodproof init` first.")
         sys.exit(1)
 
+    account_id = _require_auth(cfg)
+
     # Check for new consent categories before recording
     capture = cfg.get("capture", {})
     new_cats = (set(config.STANDARD_CATEGORIES) | {"code_capture"}) - set(capture.keys())
@@ -738,11 +883,33 @@ def cmd_start(args: argparse.Namespace) -> None:
     repo_url = args.repo or repos.detect_repo(watch_dir)
     tags = args.tags.split(",") if args.tags else []
     visibility = "public" if args.public else "private"
-    store.create_session(sid, watch_dir, repo_url, json.dumps(tags), visibility)
+    from methodproof.binding import compute_binding, compute_device_id
+    device_id = compute_device_id()
+    # Compute session binding if master key is available
+    binding = ""
+    if cfg.get("master_key_fingerprint") and account_id:
+        from methodproof.keychain import load_secret
+        from methodproof.kdf import derive_master, derive_bind_key
+        entropy = load_secret(account_id)
+        if entropy:
+            master = derive_master(entropy)
+            bind_key = derive_bind_key(master, account_id)
+            binding = compute_binding(bind_key, sid, account_id, device_id, time.time())
+    store.create_session(sid, watch_dir, repo_url, json.dumps(tags), visibility,
+                         account_id, binding, device_id)
     cfg["active_session"] = sid
     config.save(cfg)
     PIDFILE.write_text(str(os.getpid()))
 
+    # Temporal anchor — server-signed timestamp (best-effort, skip if offline)
+    if cfg.get("token"):
+        try:
+            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
+
     from methodproof.agents import base
     live_ok = False
     capture = cfg.get("capture", {})
@@ -1009,8 +1176,13 @@ def cmd_login(args: argparse.Namespace) -> None:
                 cfg["token"] = poll["token"]
                 cfg["refresh_token"] = poll.get("refresh_token", "")
                 cfg["api_url"] = api
+                # Extract account_id and persist auth timestamp
+                claims = _decode_jwt_claims(poll["token"])
+                cfg["account_id"] = claims.get("user_id", "")
+                cfg["last_auth_at"] = time.time()
                 config.save(cfg)
                 print(" done.\n")
+                _setup_master_key(cfg)
                 print("Logged in. Run `methodproof push` to upload sessions.")
                 return
         except Exception:
@@ -1443,6 +1615,9 @@ def main() -> None:
                          help="Enable auto-update before each mp start (recommended)")
     up_auto.add_argument("--no-auto", dest="auto", action="store_false",
                          help="Disable auto-update")
+    lk = sub.add_parser("lock", help="Destroy local encryption key (reversible with recovery phrase)")
+    lk.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
+    lk.add_argument("--purge", action="store_true", help="Also delete the entire database (irreversible)")
     rs = sub.add_parser("reset", help="Clear login and consent settings (keeps sessions and hooks)")
     rs.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
     un = sub.add_parser("uninstall", help="Remove all hooks, data, and config")
@@ -1474,7 +1649,7 @@ def main() -> None:
         "view": cmd_view, "log": cmd_log, "login": cmd_login,
         "push": cmd_push, "tag": cmd_tag, "publish": cmd_publish,
         "delete": cmd_delete, "review": cmd_review, "consent": cmd_consent,
-        "update": cmd_update, "reset": cmd_reset, "uninstall": cmd_uninstall,
+        "update": cmd_update, "lock": cmd_lock, "reset": cmd_reset, "uninstall": cmd_uninstall,
         "extension": cmd_extension,
         "journal": cmd_journal,
         "intro": lambda _: _print_intro(),

{methodproof-0.4.4 → methodproof-0.5.0}/methodproof/config.py

@@ -18,7 +18,8 @@ _DEFAULTS: dict[str, Any] = {
     "refresh_token": "",
     "email": "",
     "active_session": None,
-    "e2e_key": "",
+    "e2e_key": "",  # legacy — new installs use keychain-derived keys
+    "master_key_fingerprint": "",
     "capture": {
         "terminal_commands": True,
         "command_output": True,
@@ -36,6 +37,8 @@ _DEFAULTS: dict[str, Any] = {
     "journal_mode": False,
     "journal_credits": 2,
     "auto_update": False,
+    "account_id": "",
+    "last_auth_at": 0,
     "publish_redact": {
         "command_output": True,
         "ai_prompts": True,

{methodproof-0.4.4 → methodproof-0.5.0}/methodproof/hooks/install.py

@@ -91,15 +91,27 @@ def install() -> str | None:
             hooks[event] = [{"matcher": "", "hooks": [entry]}]
             changed = True
         else:
-            # Check if our hook is already installed
-            existing_cmds = [
-                h.get("command", "")
-                for group in hooks[event]
-                for h in group.get("hooks", [])
-            ]
-            if script not in existing_cmds:
-                hooks[event].append({"matcher": "", "hooks": [entry]})
+            # Remove any stale methodproof hooks (different install path)
+            cleaned = []
+            has_current = False
+            for group in hooks[event]:
+                group_hooks = []
+                for h in group.get("hooks", []):
+                    cmd = h.get("command", "")
+                    if "methodproof" in cmd:
+                        if cmd == script:
+                            has_current = True
+                            group_hooks.append(h)
+                        else:
+                            changed = True  # dropping stale entry
+                    else:
+                        group_hooks.append(h)
+                if group_hooks:
+                    cleaned.append({**group, "hooks": group_hooks})
+            if not has_current:
+                cleaned.append({"matcher": "", "hooks": [entry]})
                 changed = True
+            hooks[event] = cleaned
 
     if changed:
         settings["hooks"] = hooks

{methodproof-0.4.4 → methodproof-0.5.0}/methodproof/integrity.py

@@ -6,12 +6,15 @@ from pathlib import Path
 from typing import Any
 
 
-def compute_event_hash(event: dict[str, Any], prev_hash: str) -> str:
-    """SHA-256 of {event_id}:{type}:{timestamp}:{metadata_hash}:{prev_hash}."""
+def compute_event_hash(event: dict[str, Any], prev_hash: str, account_id: str = "") -> str:
+    """SHA-256 chain link. Includes account_id when present (new format), omits for legacy."""
     metadata_hash = hashlib.sha256(
         json.dumps(event.get("metadata", {}), sort_keys=True, default=str).encode()
     ).hexdigest()
-    payload = f"{event['id']}:{event['type']}:{event['timestamp']}:{metadata_hash}:{prev_hash}"
+    if account_id:
+        payload = f"{event['id']}:{account_id}:{event['type']}:{event['timestamp']}:{metadata_hash}:{prev_hash}"
+    else:
+        payload = f"{event['id']}:{event['type']}:{event['timestamp']}:{metadata_hash}:{prev_hash}"
     return hashlib.sha256(payload.encode()).hexdigest()
 
 

methodproof-0.5.0/methodproof/kdf.py

@@ -0,0 +1,25 @@
+"""Key derivation from master secret — HKDF-SHA256 with versioned info strings."""
+
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+
+
+def derive_master(entropy: bytes) -> bytes:
+    """128-bit entropy → 256-bit master secret."""
+    return HKDF(algorithm=SHA256(), length=32, salt=None, info=b"master-v1").derive(entropy)
+
+
+def derive_db_key(master: bytes, account_id: str) -> bytes:
+    """Master secret → AES-256 key for local DB field encryption."""
+    return HKDF(
+        algorithm=SHA256(), length=32,
+        salt=account_id.encode(), info=b"local-db-v1",
+    ).derive(master)
+
+
+def derive_bind_key(master: bytes, account_id: str) -> bytes:
+    """Master secret → HMAC key for session binding signatures."""
+    return HKDF(
+        algorithm=SHA256(), length=32,
+        salt=account_id.encode(), info=b"session-bind-v1",
+    ).derive(master)

methodproof-0.5.0/methodproof/keychain.py

@@ -0,0 +1,71 @@
+"""OS keychain storage for master secret — macOS Keychain, Linux secret-service, Windows Credential Manager."""
+
+import sys
+from pathlib import Path
+
+_SERVICE = "methodproof"
+_FALLBACK_WARNING = (
+    "  No OS keychain available. Master secret stored as file (owner-only permissions).\n"
+    "  For better security, install a keyring backend (e.g., gnome-keyring).\n"
+)
+
+
+def _fallback_path() -> Path:
+    from methodproof import config
+    return config.DIR / "master.key"
+
+
+def store_secret(account_id: str, secret: bytes) -> None:
+    """Store master secret in OS keychain, or fall back to file."""
+    try:
+        import keyring
+        keyring.set_password(_SERVICE, account_id, secret.hex())
+    except Exception:
+        _store_file(secret)
+        sys.stderr.write(_FALLBACK_WARNING)
+
+
+def load_secret(account_id: str) -> bytes | None:
+    """Load master secret from OS keychain or fallback file."""
+    try:
+        import keyring
+        val = keyring.get_password(_SERVICE, account_id)
+        if val:
+            return bytes.fromhex(val)
+    except Exception:
+        pass
+    return _load_file()
+
+
+def delete_secret(account_id: str) -> None:
+    """Remove master secret from keychain and fallback file."""
+    try:
+        import keyring
+        keyring.delete_password(_SERVICE, account_id)
+    except Exception:
+        pass
+    path = _fallback_path()
+    if path.exists():
+        path.unlink()
+
+
+def has_secret(account_id: str) -> bool:
+    return load_secret(account_id) is not None
+
+
+def _store_file(secret: bytes) -> None:
+    from methodproof.config import ensure_dirs, secure_file
+    ensure_dirs()
+    path = _fallback_path()
+    path.write_text(secret.hex())
+    secure_file(path)
+
+
+def _load_file() -> bytes | None:
+    path = _fallback_path()
+    if not path.exists():
+        return None
+    try:
+        return bytes.fromhex(path.read_text().strip())
+    except (ValueError, OSError):
+        return None

methodproof-0.5.0/methodproof/lock.py

@@ -0,0 +1,41 @@
+"""Lock/purge — destroy local key access, optionally delete all data."""
+
+import sys
+
+from methodproof import config, store
+
+
+def lock(account_id: str, purge: bool = False) -> None:
+    """Destroy master secret from keychain. Optionally delete DB entirely."""
+    from methodproof.keychain import delete_secret
+    delete_secret(account_id)
+
+    if purge:
+        import shutil
+        if config.DB_PATH.exists():
+            config.DB_PATH.unlink()
+            # Clean up WAL/SHM files
+            for suffix in (".db-wal", ".db-shm"):
+                p = config.DB_PATH.with_suffix(suffix)
+                if p.exists():
+                    p.unlink()
+        print("  Database deleted.")
+    else:
+        print("  Master key destroyed. Encrypted fields are now inaccessible.")
+        print("  Structural metadata (types, timestamps, paths) remains.")
+        print("  Restore with: mp login (enter recovery phrase)")
+
+    # Notify platform (best-effort)
+    cfg = config.load()
+    if cfg.get("token"):
+        try:
+            from methodproof.sync import _request
+            from methodproof.binding import compute_device_id
+            _request("POST", "/personal/lock-event", cfg["api_url"], cfg["token"],
+                     {"device_id": compute_device_id(), "purged": purge})
+        except Exception:
+            pass
+
+    # Clear master key fingerprint from config
+    cfg["master_key_fingerprint"] = ""
+    config.save(cfg)