methodproof 0.7.7__tar.gz → 0.7.8__tar.gz

{methodproof-0.7.7 → methodproof-0.7.8}/.gitignore

@@ -8,3 +8,5 @@ build/
 *.key
 *.pem
 .DS_Store
+.coverage
+htmlcov/

{methodproof-0.7.7 → methodproof-0.7.8}/PKG-INFO

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

{methodproof-0.7.7 → methodproof-0.7.8}/methodproof/__init__.py

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

{methodproof-0.7.7 → methodproof-0.7.8}/methodproof/cli.py

@@ -502,6 +502,8 @@ def _print_commands() -> None:
     print()
     print(f"  {_W}ACCOUNT{R}")
     print(f"    {_M}mp login{R}              Connect to platform (opens browser)")
+    print(f"    {_M}mp accounts{R}           List all accounts on this device")
+    print(f"    {_M}mp switch{R} {_D}[query]{R}     Quick-swap to another account")
     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}")
@@ -561,6 +563,8 @@ def _print_commands_plain() -> None:
     print()
     print("  ACCOUNT")
     print("    mp login              Connect to platform (opens browser)")
+    print("    mp accounts           List all accounts on this device")
+    print("    mp switch [query]     Quick-swap to another account")
     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)")
@@ -982,6 +986,13 @@ def cmd_start(args: argparse.Namespace) -> None:
     _log_step("Creating session")
     sid = uuid.uuid4().hex
     watch_dir = os.path.abspath(args.dir or ".")
+
+    # Prevent concurrent sessions watching overlapping directories
+    conflict = store.find_active_for_dir(watch_dir)
+    if conflict:
+        print(f"Active session {conflict['id'][:8]} already watches {conflict['watch_dir']}")
+        print("Run `methodproof stop` first, or choose a different directory.")
+        sys.exit(1)
     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"
@@ -1327,6 +1338,9 @@ def cmd_status(args: argparse.Namespace) -> None:
         print(f"  auth: signed in")
         print(f"  account: {account_id[:8]}...{account_id[-4:]}")
         print(f"  role: {role}  |  type: {acct_type}  |  token: {expiry}")
+        n_profiles = len(cfg.get("profiles", {}))
+        if n_profiles > 1:
+            print(f"  accounts: {n_profiles} on this device  (`mp switch` to swap)")
         if claims.get("is_superadmin"):
             print("  superadmin: yes")
 
@@ -1391,6 +1405,92 @@ def cmd_logout(args: argparse.Namespace) -> None:
     print(f"Logged out ({label}). Run `mp login` to sign in again.")
 
 
+def cmd_accounts(args: argparse.Namespace) -> None:
+    """List all accounts stored on this device."""
+    cfg = config.load()
+    profiles = config.list_profiles(cfg)
+    if not profiles:
+        print("No accounts. Run `mp login` to sign in.")
+        return
+    print()
+    for p in profiles:
+        marker = "*" if p.get("active") else " "
+        email = p.get("email", "")
+        aid = p.get("account_id", "")[:8]
+        label = email or aid or "unknown"
+        # Token status
+        token = p.get("token", "")
+        if token:
+            claims = _decode_jwt_claims(token)
+            exp = claims.get("exp", 0)
+            if exp and time.time() > exp:
+                status = "expired"
+            elif exp:
+                remaining = int(exp - time.time())
+                h, m = remaining // 3600, (remaining % 3600) // 60
+                status = f"{h}h {m}m"
+            else:
+                status = "valid"
+        else:
+            status = "no token"
+        print(f"  {marker} {label}  ({aid})  token: {status}")
+    print(f"\n  Switch: `mp switch <email or id prefix>`\n")
+
+
+def cmd_switch(args: argparse.Namespace) -> None:
+    """Quick-swap to a stored account profile."""
+    cfg = config.load()
+    profiles = cfg.get("profiles", {})
+
+    if not profiles:
+        print("No stored accounts. Run `mp login` to add one.")
+        return
+
+    query = getattr(args, "account", None)
+
+    if query:
+        # Direct match
+        target = config.find_profile(cfg, query)
+        if not target:
+            print(f"No account matching '{query}'. Run `mp accounts` to see stored accounts.")
+            return
+    else:
+        # Interactive picker
+        items = [(aid, p) for aid, p in profiles.items() if aid != cfg.get("account_id")]
+        if not items:
+            print("Only one account stored. Run `mp login` to add another.")
+            return
+        print()
+        for i, (aid, p) in enumerate(items, 1):
+            label = p.get("email") or aid[:8]
+            print(f"  {i}. {label}  ({aid[:8]})")
+        print()
+        try:
+            choice = input(f"  Switch to [1-{len(items)}]: ").strip()
+            idx = int(choice) - 1
+            if not 0 <= idx < len(items):
+                print("Cancelled.")
+                return
+        except (ValueError, EOFError, KeyboardInterrupt):
+            print("\nCancelled.")
+            return
+        target = items[idx][0]
+
+    if target == cfg.get("account_id"):
+        label = cfg.get("email") or target[:8]
+        print(f"Already active: {label}")
+        return
+
+    if config.restore_profile(cfg, target):
+        cfg = config.load()  # reload after swap
+        label = cfg.get("email") or cfg.get("account_id", "")[:8]
+        print(f"Switched to {label} ({cfg.get('account_id', '')[:8]}).")
+        # Re-setup master key for this account
+        _setup_master_key(cfg)
+    else:
+        print(f"Profile not found for {target[:8]}. Run `mp login`.")
+
+
 def cmd_login(args: argparse.Namespace) -> None:
     import webbrowser
     from methodproof.sync import _request
@@ -1404,6 +1504,8 @@ def cmd_login(args: argparse.Namespace) -> None:
         answer = input("  Switch accounts? [y/N]: ").strip().lower()
         if answer not in ("y", "yes"):
             return
+        # Stash current profile before switching
+        config.save_active_profile(cfg)
 
     # Start device auth flow
     result = _request("POST", "/auth/cli/start", api, "")
@@ -1437,12 +1539,17 @@ def cmd_login(args: argparse.Namespace) -> None:
                 cfg["last_auth_at"] = time.time()
                 cfg["master_key_fingerprint"] = ""  # clear stale fingerprint from previous account
                 config.save(cfg)
+                config.save_active_profile(cfg)
                 print(" done.\n")
                 if not getattr(args, "no_key", False):
                     _setup_master_key(cfg)
                 from methodproof.sync import sync_research_consent
                 sync_research_consent(cfg["token"], cfg["api_url"])
-                print("Logged in. Run `methodproof push` to upload sessions.")
+                label = cfg.get("email") or cfg.get("account_id", "")[:8]
+                profiles = cfg.get("profiles", {})
+                n = len(profiles)
+                print(f"Logged in as {label}. {n} account{'s' if n != 1 else ''} on this device.")
+                print("  Quick-swap: `mp switch`")
                 return
         except Exception:
             pass
@@ -1868,6 +1975,9 @@ def main() -> None:
     l.add_argument("--force", "-f", action="store_true", help="Skip switch-account prompt")
     l.add_argument("--no-key", action="store_true", help="Skip master key generation (test accounts)")
     sub.add_parser("logout", help="Clear login credentials (keeps consent and sessions)")
+    sub.add_parser("accounts", help="List all accounts on this device")
+    sw = sub.add_parser("switch", help="Quick-swap to another account")
+    sw.add_argument("account", nargs="?", help="Email or account ID prefix")
     pu = sub.add_parser("push", help="Upload privately to your account")
     pu.add_argument("session_id", nargs="?")
     pu.add_argument("--local", action="store_true", help="Push to local dev API (localhost:8000)")
@@ -1928,7 +2038,7 @@ def main() -> None:
     cmds = {
         "init": cmd_init, "start": cmd_start, "stop": cmd_stop,
         "view": cmd_view, "log": cmd_log, "status": cmd_status,
-        "login": cmd_login, "logout": cmd_logout,
+        "login": cmd_login, "logout": cmd_logout, "accounts": cmd_accounts, "switch": cmd_switch,
         "push": cmd_push, "tag": cmd_tag, "publish": cmd_publish,
         "delete": cmd_delete, "review": cmd_review, "consent": cmd_consent,
         "update": cmd_update, "lock": cmd_lock, "reset": cmd_reset, "uninstall": cmd_uninstall,

{methodproof-0.7.7 → methodproof-0.7.8}/methodproof/config.py

@@ -50,6 +50,7 @@ _DEFAULTS: dict[str, Any] = {
         "ai_responses": True,
         "code_capture": True,
     },
+    "profiles": {},
 }
 
 FREE_JOURNAL_MAX_HOURS = 4
@@ -154,3 +155,60 @@ def save(cfg: dict[str, Any]) -> None:
     ensure_dirs()
     CONFIG.write_text(json.dumps(cfg, indent=2) + "\n")
     secure_file(CONFIG)
+
+
+# --- Multi-account profiles ---
+
+_PROFILE_KEYS = [
+    "token", "refresh_token", "email", "account_id",
+    "last_auth_at", "master_key_fingerprint",
+    "e2e_mode", "e2e_fingerprint",
+    "journal_mode", "journal_credits",
+]
+
+
+def save_active_profile(cfg: dict[str, Any]) -> None:
+    """Stash current auth state into profiles dict, keyed by account_id."""
+    aid = cfg.get("account_id")
+    if not aid:
+        return
+    profiles = cfg.setdefault("profiles", {})
+    profiles[aid] = {k: cfg.get(k, _DEFAULTS.get(k, "")) for k in _PROFILE_KEYS}
+    save(cfg)
+
+
+def restore_profile(cfg: dict[str, Any], account_id: str) -> bool:
+    """Swap active auth state to a stored profile. Returns False if not found."""
+    profiles = cfg.get("profiles", {})
+    profile = profiles.get(account_id)
+    if not profile:
+        return False
+    save_active_profile(cfg)
+    for k in _PROFILE_KEYS:
+        cfg[k] = profile.get(k, _DEFAULTS.get(k, ""))
+    save(cfg)
+    return True
+
+
+def list_profiles(cfg: dict[str, Any]) -> list[dict[str, Any]]:
+    """Return stored profiles with 'active' flag on the current account."""
+    active_id = cfg.get("account_id", "")
+    profiles = cfg.get("profiles", {})
+    result = []
+    for aid, p in profiles.items():
+        result.append({**p, "active": aid == active_id})
+    if active_id and active_id not in profiles:
+        result.append({
+            k: cfg.get(k, _DEFAULTS.get(k, "")) for k in _PROFILE_KEYS
+        } | {"active": True})
+    return result
+
+
+def find_profile(cfg: dict[str, Any], query: str) -> str | None:
+    """Match a profile by email or account_id prefix. Returns account_id or None."""
+    profiles = cfg.get("profiles", {})
+    q = query.lower().strip()
+    for aid, p in profiles.items():
+        if p.get("email", "").lower() == q or aid.startswith(q):
+            return aid
+    return None

{methodproof-0.7.7 → methodproof-0.7.8}/methodproof/store.py

@@ -1,6 +1,7 @@
 """SQLite store — sessions, events, graph relationships."""
 
 import json
+import os
 import sqlite3
 import time
 import uuid
@@ -165,6 +166,20 @@ def create_session(
     _db().commit()
 
 
+def find_active_for_dir(watch_dir: str) -> dict[str, str] | None:
+    """Find an active session watching the same or overlapping directory."""
+    rows = _db().execute(
+        "SELECT id, watch_dir FROM sessions WHERE completed_at IS NULL",
+    ).fetchall()
+    for r in rows:
+        existing = r[1]
+        if (watch_dir == existing
+                or watch_dir.startswith(existing + os.sep)
+                or existing.startswith(watch_dir + os.sep)):
+            return {"id": r[0], "watch_dir": r[1]}
+    return None
+
+
 def complete_session(session_id: str) -> None:
     db = _db()
     count = db.execute(

{methodproof-0.7.7 → methodproof-0.7.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "methodproof"
-version = "0.7.7"
+version = "0.7.8"
 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"]
@@ -11,7 +11,7 @@ readme = "README.md"
 proxy = ["mitmproxy>=10.0"]
 
 [dependency-groups]
-dev = ["pytest>=8.0"]
+dev = ["pytest>=8.0", "pytest-cov>=5.0"]
 
 [project.scripts]
 methodproof = "methodproof.cli:main"
@@ -25,3 +25,13 @@ packages = ["methodproof"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+markers = [
+    "e2e: requires Docker infrastructure (just infra-up && just seed && just platform)",
+]
+
+[tool.coverage.run]
+source = ["methodproof"]
+omit = ["methodproof/wordlist.py"]
+
+[tool.coverage.report]
+show_missing = true

methodproof-0.7.8/tests/conftest.py

@@ -0,0 +1,131 @@
+"""Shared fixtures for CLI tests."""
+
+import argparse
+import base64
+import json
+import time
+import uuid
+import zlib
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from methodproof import config, store
+
+
+# ── Filesystem isolation ──
+
+
+@pytest.fixture(autouse=True)
+def isolate_fs(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    """Isolate all config/DB/log paths to tmp_path. Writes defaults to disk
+    so config.load() always parses JSON (avoids _DEFAULTS shallow-copy mutation)."""
+    mp_dir = tmp_path / ".methodproof"
+    mp_dir.mkdir()
+    monkeypatch.setattr(config, "DIR", mp_dir)
+    monkeypatch.setattr(config, "CONFIG", mp_dir / "config.json")
+    monkeypatch.setattr(config, "DB_PATH", mp_dir / "methodproof.db")
+    monkeypatch.setattr(config, "CMD_LOG", mp_dir / "commands.jsonl")
+    (mp_dir / "config.json").write_text(json.dumps(dict(config._DEFAULTS), indent=2))
+    monkeypatch.setattr(store, "_conn", None)
+    store.init_db()
+    return tmp_path
+
+
+# ── JWT helper ──
+
+
+@pytest.fixture
+def fake_jwt():
+    """Factory: builds a real base64-encoded JWT so _decode_jwt_claims works."""
+    def _make(
+        user_id: str = "test-account-123",
+        role: str = "admin",
+        account_type: str = "pro",
+        exp: float | None = None,
+        **extra: Any,
+    ) -> str:
+        header = base64.urlsafe_b64encode(b'{"alg":"HS256","typ":"JWT"}').rstrip(b"=").decode()
+        claims = {
+            "user_id": user_id,
+            "role": role,
+            "account_type": account_type,
+            "exp": exp if exp is not None else time.time() + 3600,
+            **extra,
+        }
+        payload = base64.urlsafe_b64encode(json.dumps(claims).encode()).rstrip(b"=").decode()
+        sig = base64.urlsafe_b64encode(b"fakesig").rstrip(b"=").decode()
+        return f"{header}.{payload}.{sig}"
+    return _make
+
+
+# ── Config helpers ──
+
+
+@pytest.fixture
+def logged_in_cfg(fake_jwt):
+    """Factory: writes a config with valid auth state, returns cfg dict."""
+    def _make(
+        account_id: str = "test-account-123",
+        email: str = "test@methodproof.com",
+        token: str | None = None,
+        **extra: Any,
+    ) -> dict[str, Any]:
+        cfg = config.load()
+        cfg["token"] = token or fake_jwt(user_id=account_id)
+        cfg["account_id"] = account_id
+        cfg["email"] = email
+        cfg["last_auth_at"] = time.time()
+        cfg.update(extra)
+        config.save(cfg)
+        return cfg
+    return _make
+
+
+# ── Session factory ──
+
+
+@pytest.fixture
+def make_session():
+    """Factory: creates a completed session with N events in SQLite."""
+    def _make(n_events: int = 5, account_id: str = "test-account-123",
+              watch_dir: str = "/tmp/test", **session_kwargs: Any) -> tuple[str, list[dict]]:
+        sid = uuid.uuid4().hex
+        store.create_session(sid, watch_dir, account_id=account_id, **session_kwargs)
+        events = []
+        base_ts = time.time() - 300
+        for i in range(n_events):
+            e = {
+                "id": uuid.uuid4().hex,
+                "type": ["file_edit", "terminal_cmd", "llm_prompt", "git_commit", "test_run"][i % 5],
+                "timestamp": base_ts + i * 10,
+                "duration_ms": 100 + i * 50,
+                "metadata": {"path": f"file_{i}.py", "language": "python"},
+            }
+            events.append(e)
+        store.insert_events(sid, events)
+        store.complete_session(sid)
+        return sid, events
+    return _make
+
+
+# ── Argparse helper ──
+
+
+@pytest.fixture
+def cli_args():
+    """Factory: builds argparse.Namespace with sensible defaults."""
+    def _make(**kwargs: Any) -> argparse.Namespace:
+        defaults = {
+            "session_id": None, "dir": None, "repo": None, "tags": None,
+            "public": False, "live": False, "live_public": False,
+            "journal": False, "e2e": False, "no_e2e": False,
+            "verbose": False, "streaming": False, "force": False,
+            "local": False, "api_url": None, "no_key": False, "auto": None,
+            "account": None, "purge": False, "keep_sessions": False,
+            "anonymous": False,
+        }
+        defaults.update(kwargs)
+        return argparse.Namespace(**defaults)
+    return _make