epi-recorder 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

epi_cli/__main__.py

@@ -1,5 +1,10 @@
 """
-EPI CLI entry point for python -m epi_cli
+EPI CLI - Main entry point for python -m epi_cli
+
+This allows users to run the CLI even if 'epi' is not in PATH:
+    python -m epi_cli run script.py
+    python -m epi_cli view recording.epi
+    etc.
 """
 from epi_cli.main import cli_main
 

epi_cli/main.py

@@ -231,43 +231,79 @@ def doctor():
     """
     [Doctor] Self-healing doctor. Fixes common issues silently.
     """
-    console.print("\n[bold blue]EPI Doctor[/bold blue]\n")
+    console.print("\n[bold blue]EPI Doctor - System Health Check[/bold blue]\n")
     
     issues = 0
+    fixed = 0
     
     # Check 1: Keys
     console.print("1. Security Keys: ", end="")
     from epi_cli.keys import generate_default_keypair_if_missing
     if generate_default_keypair_if_missing(console_output=False):
-        console.print("[green]FIXED (Generated)[/green]")
-        issues += 1
+        console.print("[green][OK] FIXED (Generated)[/green]")
+        fixed += 1
     else:
-        console.print("[green]OK[/green]")
+        console.print("[green][OK][/green]")
         
     # Check 2: Command on PATH
     console.print("2. 'epi' command: ", end="")
     import shutil
     if shutil.which("epi"):
-        console.print("[green]OK[/green]")
+        console.print("[green][OK][/green]")
     else:
-        console.print("[red]MISSING[/red]")
-        console.print("   [yellow]Run: python epi_setup.py[/yellow]")
+        console.print("[red][X] NOT IN PATH[/red]")
         issues += 1
+        
+        # Try to auto-fix on Windows
+        import platform
+        if platform.system() == "Windows":
+            console.print("   [cyan]→ Attempting automatic PATH fix...[/cyan]")
+            try:
+                import epi_postinstall
+                from pathlib import Path
+                
+                scripts_dir = epi_postinstall.get_scripts_dir()
+                if scripts_dir and scripts_dir.exists():
+                    console.print(f"   [dim]Scripts directory: {scripts_dir}[/dim]")
+                    
+                    if epi_postinstall.add_to_user_path_windows(scripts_dir):
+                        console.print("   [green][OK] PATH updated successfully![/green]")
+                        console.print("   [yellow][!] Please restart your terminal for changes to take effect[/yellow]")
+                        fixed += 1
+                    else:
+                        console.print("   [yellow][!] Could not update PATH automatically[/yellow]")
+                        console.print("   [dim]Manual fix: Use 'python -m epi_cli' instead[/dim]")
+                else:
+                    console.print("   [red][X] Could not locate Scripts directory[/red]")
+            except Exception as e:
+                console.print(f"   [red][X] Auto-fix failed: {e}[/red]")
+                console.print("   [dim]Workaround: Use 'python -m epi_cli' instead[/dim]")
+        else:
+            console.print("   [dim]Workaround: Use 'python -m epi_cli' instead[/dim]")
 
     # Check 3: Browser
     console.print("3. Browser Check: ", end="")
     try:
         import webbrowser
         webbrowser.get()
-        console.print("[green]OK[/green]")
+        console.print("[green][OK][/green]")
     except:
-        console.print("[yellow]WARNING (Headless?)[/yellow]")
+        console.print("[yellow][!] WARNING (Headless?)[/yellow]")
         
+    # Summary
     print()
+    console.print("[bold]" + "="*70 + "[/bold]")
     if issues == 0:
         console.print("[bold green][OK] System Healthy![/bold green]")
     else:
-        console.print(f"[bold yellow][!] Found {issues} issues.[/bold yellow]")
+        if fixed > 0:
+            console.print(f"[bold yellow][!] Fixed {fixed}/{issues} issues[/bold yellow]")
+            if fixed < issues:
+                console.print("[dim]Some issues require manual attention (see above)[/dim]")
+        else:
+            console.print(f"[bold yellow][!] Found {issues} issues[/bold yellow]")
+            console.print("[dim]See suggestions above[/dim]")
+    console.print("[bold]" + "="*70 + "[/bold]\n")
 
 
 # Entry point for CLI

epi_core/__init__.py

@@ -2,7 +2,7 @@
 EPI Core - Core data structures, serialization, and container management.
 """
 
-__version__ = "2.1.0"
+__version__ = "2.1.1"
 
 from epi_core.schemas import ManifestModel, StepModel
 from epi_core.serialize import get_canonical_hash

epi_core/container.py

@@ -80,6 +80,8 @@ class EPIContainer:
         # Read template and assets
         template_html = template_path.read_text(encoding="utf-8")
         app_js = app_js_path.read_text(encoding="utf-8") if app_js_path.exists() else ""
+        crypto_js_path = viewer_static_dir / "crypto.js"
+        crypto_js = crypto_js_path.read_text(encoding="utf-8") if crypto_js_path.exists() else ""
         css_styles = css_path.read_text(encoding="utf-8") if css_path.exists() else ""
         
         # Read steps from steps.jsonl
@@ -112,10 +114,16 @@ class EPIContainer:
             f'<style>{css_styles}</style>'
         )
         
-        # Inline app.js
+        # Inline crypto.js and app.js
+        js_content = ""
+        if crypto_js:
+            js_content += f"<script>{crypto_js}</script>\n"
+        if app_js:
+            js_content += f"<script>{app_js}</script>"
+            
         html_with_js = html_with_css.replace(
             '<script src="app.js"></script>',
-            f'<script>{app_js}</script>'
+            js_content
         )
         
         return html_with_js

epi_core/schemas.py

@@ -18,7 +18,7 @@ class ManifestModel(BaseModel):
     """
     
     spec_version: str = Field(
-        default="1.0-keystone",
+        default="1.1-json",
         description="EPI specification version"
     )
     
@@ -47,6 +47,11 @@ class ManifestModel(BaseModel):
         description="Mapping of file paths to their SHA-256 hashes for integrity verification"
     )
     
+    public_key: Optional[str] = Field(
+        default=None,
+        description="Hex-encoded public key used for verification"
+    )
+    
     signature: Optional[str] = Field(
         default=None,
         description="Ed25519 signature of the canonical CBOR hash of this manifest (excluding signature field)"

epi_core/serialize.py

@@ -87,27 +87,56 @@ def get_canonical_hash(model: BaseModel, exclude_fields: set[str] | None = None)
         else:
             return value
     
+    # Normalize datetime and UUID fields to strings
     model_dict = normalize_value(model_dict)
     
     if exclude_fields:
         for field in exclude_fields:
             model_dict.pop(field, None)
-    
+
+    # JSON Canonicalization for Spec v1.1+
+    # Check if model has spec_version and if it indicates JSON usage
+    # We default to CBOR for backward compatibility
+    
+    use_json = False
+    
+    # Check spec_version in model or dict
+    spec_version = model_dict.get("spec_version")
+    if spec_version and (spec_version.startswith("1.1") or "json" in spec_version):
+        use_json = True
+        
+    if use_json:
+        return _get_json_canonical_hash(model_dict)
+    else:
+        return _get_cbor_canonical_hash(model_dict)
+
+
+def _get_json_canonical_hash(data: Any) -> str:
+    """Compute canonical SHA-256 hash using JSON (RFC 8785 style)."""
+    import json
+    
+    # Dump to JSON with sorted keys and no whitespace
+    json_bytes = json.dumps(
+        data,
+        sort_keys=True,
+        separators=(',', ':'),
+        ensure_ascii=False
+    ).encode("utf-8")
+    
+    return hashlib.sha256(json_bytes).hexdigest()
+
+
+def _get_cbor_canonical_hash(data: Any) -> str:
+    """Compute canonical SHA-256 hash using CBOR (Legacy v1.0)."""
     # Encode to canonical CBOR
-    # canonical=True ensures:
-    # - Keys are sorted lexicographically
-    # - Minimal encoding is used
-    # - Deterministic representation
     cbor_bytes = cbor2.dumps(
-        model_dict,
+        data,
         canonical=True,
         default=_cbor_default_encoder
     )
     
     # Compute SHA-256 hash
-    hash_obj = hashlib.sha256(cbor_bytes)
-    
-    return hash_obj.hexdigest()
+    return hashlib.sha256(cbor_bytes).hexdigest()
 
 
 def verify_hash(model: BaseModel, expected_hash: str, exclude_fields: set[str] | None = None) -> bool:

epi_core/trust.py

@@ -53,6 +53,16 @@ def sign_manifest(
         SigningError: If signing fails
     """
     try:
+        # Derive public key and add to manifest
+        public_key_obj = private_key.public_key()
+        public_key_hex = public_key_obj.public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw
+        ).hex()
+        
+        # We must update the manifest BEFORE hashing so the public key is signed
+        manifest.public_key = public_key_hex
+
         # Compute canonical hash (excluding signature field)
         manifest_hash = get_canonical_hash(manifest, exclude_fields={"signature"})
         hash_bytes = bytes.fromhex(manifest_hash)

epi_postinstall.py

@@ -0,0 +1,197 @@
+"""
+Post-installation script for EPI Recorder
+Automatically fixes PATH issues on Windows for better UX
+"""
+import sys
+import os
+import platform
+import subprocess
+from pathlib import Path
+
+
+def get_scripts_dir():
+    """Get the Scripts directory where pip installs executables"""
+    if platform.system() == "Windows":
+        # Get the site-packages directory
+        import site
+        user_site = site.getusersitepackages()
+        if user_site:
+            # Scripts is typically ../Scripts relative to site-packages
+            scripts_dir = Path(user_site).parent / "Scripts"
+            if scripts_dir.exists():
+                return scripts_dir
+        
+        # Fallback: try to find it from pip
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "show", "epi-recorder"],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode == 0:
+                for line in result.stdout.split('\n'):
+                    if line.startswith('Location:'):
+                        location = line.split(':', 1)[1].strip()
+                        scripts_dir = Path(location).parent / "Scripts"
+                        if scripts_dir.exists():
+                            return scripts_dir
+        except Exception:
+            pass
+    
+    return None
+
+
+def is_in_path(directory):
+    """Check if directory is in PATH"""
+    path_env = os.environ.get('PATH', '')
+    path_dirs = path_env.split(os.pathsep)
+    dir_str = str(directory)
+    return any(os.path.normcase(p) == os.path.normcase(dir_str) for p in path_dirs)
+
+
+def add_to_user_path_windows(directory):
+    """Add directory to user PATH on Windows"""
+    try:
+        import winreg
+        
+        # Open the user environment variables key
+        key = winreg.OpenKey(
+            winreg.HKEY_CURRENT_USER,
+            'Environment',
+            0,
+            winreg.KEY_READ | winreg.KEY_WRITE
+        )
+        
+        try:
+            # Get current PATH
+            current_path, _ = winreg.QueryValueEx(key, 'Path')
+        except WindowsError:
+            current_path = ''
+        
+        # Add our directory if not already there
+        path_parts = current_path.split(os.pathsep)
+        dir_str = str(directory)
+        
+        if not any(os.path.normcase(p) == os.path.normcase(dir_str) for p in path_parts):
+            new_path = current_path + os.pathsep + dir_str
+            winreg.SetValueEx(key, 'Path', 0, winreg.REG_EXPAND_SZ, new_path)
+            winreg.CloseKey(key)
+            
+            # Broadcast WM_SETTINGCHANGE to notify the system
+            try:
+                import ctypes
+                HWND_BROADCAST = 0xFFFF
+                WM_SETTINGCHANGE = 0x1A
+                ctypes.windll.user32.SendMessageW(
+                    HWND_BROADCAST, WM_SETTINGCHANGE, 0, 'Environment'
+                )
+            except Exception:
+                pass
+            
+            return True
+        
+        winreg.CloseKey(key)
+        return False
+        
+    except Exception as e:
+        print(f"Warning: Could not modify PATH: {e}")
+        return False
+
+
+def check_epi_command():
+    """Check if 'epi' command is accessible"""
+    try:
+        result = subprocess.run(
+            ['epi', '--version'],
+            capture_output=True,
+            timeout=2
+        )
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def post_install():
+    """Main post-install function"""
+    print("\n" + "="*70)
+    print("🎉 EPI Recorder Installation Complete!")
+    print("="*70)
+    
+    # Check if epi command works
+    if check_epi_command():
+        print("\n✅ The 'epi' command is ready to use!")
+        print("\nTry it now:")
+        print("  epi --help")
+        print("  epi init")
+        return
+    
+    # If not, try to fix it (Windows only for now)
+    if platform.system() == "Windows":
+        print("\n⚠️  'epi' command not found in PATH")
+        print("🔧 Attempting automatic fix...")
+        
+        scripts_dir = get_scripts_dir()
+        
+        if scripts_dir and scripts_dir.exists():
+            print(f"📁 Found Scripts directory: {scripts_dir}")
+            
+            if not is_in_path(scripts_dir):
+                print("➕ Adding to your user PATH...")
+                
+                try:
+                    if add_to_user_path_windows(scripts_dir):
+                        print("\n✅ SUCCESS! PATH updated.")
+                        print("\n⚠️  IMPORTANT: You must restart your terminal for changes to take effect!")
+                        print("\nAfter restarting your terminal, try:")
+                        print("  epi --help")
+                        print("  epi init")
+                    else:
+                        print("\n⚠️  Scripts directory already in PATH, but 'epi' not found.")
+                        print("This might require a terminal restart.")
+                        print("\nIf 'epi' still doesn't work after restarting, use:")
+                        print(f"  python -m epi_cli")
+                except Exception as e:
+                    print(f"\n❌ Automatic fix failed: {e}")
+                    show_manual_instructions(scripts_dir)
+            else:
+                print("✅ Scripts directory is in PATH")
+                print("⚠️  You may need to restart your terminal for the command to work.")
+        else:
+            print("❌ Could not locate Scripts directory")
+            show_fallback_instructions()
+    else:
+        # Linux/Mac
+        print("\n⚠️  'epi' command not found in PATH")
+        print("\nIf 'epi' doesn't work, use:")
+        print("  python -m epi_cli")
+        print("\nOr add pip's user base bin directory to PATH:")
+        print("  export PATH=$PATH:$(python -m site --user-base)/bin")
+    
+    print("\n" + "="*70 + "\n")
+
+
+def show_manual_instructions(scripts_dir):
+    """Show manual PATH update instructions"""
+    print("\n📖 MANUAL FIX REQUIRED:")
+    print("\nOption 1: Update PATH (Permanent)")
+    print("  1. Press Win + R, type: sysdm.cpl")
+    print("  2. Advanced → Environment Variables")
+    print("  3. Under 'User variables', select 'Path' → Edit")
+    print("  4. Click 'New' and add:")
+    print(f"     {scripts_dir}")
+    print("  5. Click OK, restart your terminal")
+    print("\nOption 2: Use python -m (Always works)")
+    print("  python -m epi_cli run script.py")
+
+
+def show_fallback_instructions():
+    """Show fallback instructions if automatic fix fails"""
+    print("\n📖 WORKAROUND:")
+    print("\nUse 'python -m epi_cli' instead of 'epi':")
+    print("  python -m epi_cli --help")
+    print("  python -m epi_cli run script.py")
+    print("  python -m epi_cli view recording.epi")
+
+
+if __name__ == "__main__":
+    post_install()

epi_recorder/__init__.py

@@ -4,7 +4,7 @@ EPI Recorder - Runtime interception and workflow capture.
 Python API for recording AI workflows with cryptographic verification.
 """
 
-__version__ = "2.1.0"
+__version__ = "2.1.1"
 
 # Export Python API
 from epi_recorder.api import (