Agent Zero Medic - It Be nice to have a Button

[johnnycoderbot-cloud]

🩺 Agent Zero Medic - Lightweight Recovery Tool

A tiny (~11KB) first-aid kit for when Agent Zero crashes.

---

What is it?

Agent Zero Medic is a standalone Python script that diagnoses and repairs broken Agent Zero installations. When your 4GB+ Agent Zero environment breaks, this 11KB tool gets you back to a repairable state.

---

✨ Features

Feature | Description -- | -- 🔍 Diagnose | Scans for missing files, broken imports, wrong paths 🔧 Repair | Fixes .env paths, repairs imports, creates missing directories 📦 Restore | Extracts from backup ZIP files ✅ Verify | Confirms installation works before you try to start 🖥️ Interactive | GUI file picker or text input when auto-detect fails 🌐 Multi-Platform | Windows, WSL, Docker - auto-detects and adapts

---

💡 Why I made this

After moving Agent Zero between machines and dealing with hardcoded paths breaking, I wanted a tiny, portable tool that could fix the most common issues without needing a working Python environment or internet access.

---

🔗 Code

#!/usr/bin/env python3
"""Agent Zero Medic - github.com/yourusername/agent-zero-medic"""
# Full code: [attach agent-zero-medic.py]

content_copy

🩺 Agent Zero Medic - Lightweight Recovery Tool A tiny (~11KB) first-aid kit for when Agent Zero crashes.

What is it?
Agent Zero Medic is a standalone Python script that diagnoses and repairs broken Agent Zero installations. When your 4GB+ Agent Zero environment breaks, this 11KB tool gets you back to a repairable state.

✨ Features
Feature Description
🔍 Diagnose Scans for missing files, broken imports, wrong paths
🔧 Repair Fixes .env paths, repairs imports, creates missing directories
📦 Restore Extracts from backup ZIP files
✅ Verify Confirms installation works before you try to start
🖥️ Interactive GUI file picker or text input when auto-detect fails
🌐 Multi-Platform Windows, WSL, Docker - auto-detects and adapts

🚀 Quick Start

Download medic.py to your Agent Zero folder

Or anywhere - it will find Agent Zero automatically

Full repair cycle

python agent-zero-medic.py --all

Or step by step

python agent-zero-medic.py --diagnose # Check what's broken
python agent-zero-medic.py --repair # Fix issues
python agent-zero-medic.py --verify # Confirm it works

🛠️ What it fixes
Common crash causes:

❌ Missing usr/skills/, logs/, tmp/ directories
❌ Broken imports: from helpers. → from python.helpers.
❌ Wrong paths in .env (Linux paths on Windows, etc.)
❌ Corrupted or missing core files
Platform-specific fixes:

Windows: /root/ → C:/Users/...
WSL: C:\ → /mnt/c/
Docker: Windows paths → /a0/
📋 Usage Examples

Auto-detect and repair

python agent-zero-medic.py --all

Manual path (if auto-detect fails)

python agent-zero-medic.py --path "C:\Tools\agent-zero" --all

Interactive mode (GUI picker or text input)

python agent-zero-medic.py --interactive

Restore from backup

python agent-zero-medic.py --restore backup-2024-01-15.zip

📊 Size Comparison
Component Size
Full Agent Zero ~4GB+
Agent Zero Medic ~11KB

💡 Why I made this
After moving Agent Zero between machines and dealing with hardcoded paths breaking, I wanted a tiny, portable tool that could fix the most common issues without needing a working Python environment or internet access.

🔗 Code
#!/usr/bin/env python3
"""Agent Zero Medic - github.com/yourusername/agent-zero-medic"""

Full code: [attach agent-zero-medic.py]

[johnnycoderbot-cloud]

agent-zero-medic.py

[johnnycoderbot-cloud]

#!/usr/bin/env python3
"""
Agent Zero Medic - Lightweight Recovery Tool
Supports: Windows bare metal, WSL, Docker
"""

import os
import sys
import json
import shutil
import zipfile
import re
import platform
from pathlib import Path
from datetime import datetime

class Medic:
def init(self, a0_path=None, interactive=False):
self.platform = self._detect_platform()
self.a0_path = a0_path or self._find_a0(interactive)
self.issues = []
self.fixed = []

def _detect_platform(self):
    """Detect runtime environment"""
    if os.path.exists('/.dockerenv') or os.environ.get('A0_DOCKER'):
        return 'docker'
    elif 'microsoft' in platform.release().lower() or 'WSL' in os.environ.get('WSL_DISTRO_NAME', ''):
        return 'wsl'
    elif platform.system() == 'Windows':
        return 'windows'
    else:
        return 'linux'

def _find_a0(self, interactive=False):
    """Auto-detect Agent Zero installation"""
    # Check env var first
    if 'A0_ROOT' in os.environ:
        return os.environ['A0_ROOT']
    
    # Platform-specific checks
    checks = []
    if self.platform == 'windows':
        checks = [os.getcwd(), 'C:\\agent-zero', os.path.expanduser('~\\agent-zero')]
    elif self.platform == 'wsl':
        checks = [os.getcwd(), '/home/*/agent-zero', '/mnt/c/agent-zero']
    else:  # docker/linux
        checks = [os.getcwd(), '/a0', '/root/agent-zero', '/app']
    
    for path in checks:
        expanded = os.path.expandvars(os.path.expanduser(path))
        if '*' in expanded:
            import glob
            matches = glob.glob(expanded)
            if matches:
                expanded = matches[0]
        if os.path.exists(os.path.join(expanded, 'python/main.py')):
            return expanded
    
    # If not found and interactive mode, ask user
    if interactive or not os.path.exists(os.path.join(os.getcwd(), 'python/main.py')):
        return self._prompt_for_path()
    
    return os.getcwd()

def _prompt_for_path(self):
    """Interactive path selection"""
    print("\n📂 Agent Zero not found automatically.")
    print("="*50)
    
    # Try to use tkinter file dialog if available
    try:
        import tkinter as tk
        from tkinter import filedialog
        
        print("Opening file picker...")
        root = tk.Tk()
        root.withdraw()  # Hide main window
        
        path = filedialog.askdirectory(
            title="Select Agent Zero Directory",
            initialdir=os.path.expanduser('~')
        )
        root.destroy()
        
        if path and os.path.exists(os.path.join(path, 'python/main.py')):
            print(f"✅ Selected: {path}")
            return path
        elif path:
            print(f"⚠️ {path} doesn't look like Agent Zero (no python/main.py)")
    except ImportError:
        pass  # Fall back to text input
    
    # Text input fallback
    while True:
        print("\nEnter path to Agent Zero (or 'q' to quit):")
        print("Examples:")
        if self.platform == 'windows':
            print("  C:\\Users\\You\\agent-zero")
            print("  D:\\Tools\\agent-zero")
        elif self.platform == 'wsl':
            print("  /home/you/agent-zero")
            print("  /mnt/c/agent-zero")
        else:
            print("  /a0")
            print("  /home/you/agent-zero")
        
        user_path = input("\nPath: ").strip().strip('"').strip("'")
        
        if user_path.lower() == 'q':
            print("Exiting...")
            sys.exit(0)
        
        # Expand user and vars
        expanded = os.path.expandvars(os.path.expanduser(user_path))
        
        if os.path.exists(os.path.join(expanded, 'python/main.py')):
            print(f"✅ Found Agent Zero at: {expanded}")
            return expanded
        elif os.path.exists(expanded):
            print(f"⚠️ {expanded} exists but doesn't look like Agent Zero")
            print("   (missing python/main.py)")
            retry = input("Use anyway? (y/n): ").strip().lower()
            if retry == 'y':
                return expanded
        else:
            print(f"❌ Path not found: {expanded}")

def diagnose(self):
    """Scan for issues"""
    print(f"🔍 Platform: {self.platform.upper()}")
    print(f"🔍 Path: {self.a0_path}")
    self.issues = []
    
    # Check core files
    core_files = ['python/main.py', 'python/helpers.py']
    for f in core_files:
        path = os.path.join(self.a0_path, f)
        if not os.path.exists(path):
            self.issues.append(f'Missing: {f}')
    
    # Check .env for wrong paths
    env_path = os.path.join(self.a0_path, '.env')
    if os.path.exists(env_path):
        with open(env_path, 'r') as f:
            env_content = f.read()
        
        if self.platform == 'windows':
            if '/root/' in env_content or '/tmp/' in env_content:
                self.issues.append('Linux paths in .env (needs Windows paths)')
        elif self.platform in ('wsl', 'linux'):
            if 'C:\\' in env_content:
                self.issues.append('Windows paths in .env (needs Linux paths)')
    
    # Check directories
    dirs = ['usr/skills', 'usr/uploads', 'usr/memory', 'logs', 'tmp']
    for d in dirs:
        path = os.path.join(self.a0_path, d)
        if not os.path.exists(path):
            self.issues.append(f'Missing dir: {d}')
    
    print(f'   Found {len(self.issues)} issues')
    for issue in self.issues:
        print(f'   ❌ {issue}')
    return len(self.issues)

def repair(self):
    """Fix detected issues"""
    print('\n🔧 Repairing...')
    self.fixed = []
    
    # Create directories
    dirs = ['usr/skills', 'usr/uploads', 'usr/memory', 'logs', 'tmp', 'workspace']
    for d in dirs:
        path = os.path.join(self.a0_path, d)
        if not os.path.exists(path):
            os.makedirs(path, exist_ok=True)
            self.fixed.append(f'Created: {d}')
    
    # Fix .env paths
    env_path = os.path.join(self.a0_path, '.env')
    if os.path.exists(env_path):
        with open(env_path, 'r') as f:
            content = f.read()
        original = content
        
        if self.platform == 'windows':
            content = content.replace('/root/', 'C:/Users/EmployBot/')
            content = content.replace('/tmp/', 'C:/a0/tmp/')
            content = content.replace('/a0/', 'C:/a0/')
        elif self.platform in ('wsl', 'linux', 'docker'):
            content = re.sub(r'C:\\Users\\[^\\]+\\', '/home/user/', content)
            content = content.replace('C:/', '/mnt/c/')
            content = content.replace('\\', '/')
        
        if content != original:
            with open(env_path, 'w') as f:
                f.write(content)
            self.fixed.append('Fixed: .env paths')
    
    # Fix imports
    for py_dir in ['python', 'tools']:
        py_path = os.path.join(self.a0_path, py_dir)
        if os.path.exists(py_path):
            for root, _, files in os.walk(py_path):
                for file in files:
                    if file.endswith('.py'):
                        self._fix_imports(os.path.join(root, file))
    
    print(f'   Fixed {len(self.fixed)} issues')
    for fix in self.fixed:
        print(f'   ✅ {fix}')
    return len(self.fixed)

def _fix_imports(self, filepath):
    """Fix broken import statements"""
    try:
        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
            content = f.read()
        original = content
        content = re.sub(r'from helpers\.', 'from python.helpers.', content)
        if content != original:
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(content)
            self.fixed.append(f'Fixed imports: {os.path.basename(filepath)}')
    except:
        pass

def restore(self, zip_path):
    """Restore from backup ZIP"""
    print(f'\n📦 Restoring from: {zip_path}')
    if not os.path.exists(zip_path):
        print('   ❌ ZIP not found')
        return False
    
    with zipfile.ZipFile(zip_path, 'r') as z:
        z.extractall(self.a0_path)
    print('   ✅ Restored')
    return True

def verify(self):
    """Verify installation"""
    print('\n✅ Verifying...')
    sys.path.insert(0, os.path.join(self.a0_path, 'python'))
    try:
        import helpers
        print('   ✅ helpers.py imports')
        return True
    except Exception as e:
        print(f'   ❌ helpers.py failed: {e}')
        return False

def report(self):
    print('\n' + '='*50)
    print('📋 MEDIC REPORT')
    print('='*50)
    print(f'Platform: {self.platform}')
    print(f'Path: {self.a0_path}')
    print(f'Issues: {len(self.issues)} | Fixed: {len(self.fixed)}')

def main():
import argparse
parser = argparse.ArgumentParser(description='Agent Zero Medic')
parser.add_argument('--path', help='Path to Agent Zero (auto-detect if not set)')
parser.add_argument('--interactive', '-i', action='store_true', help='Interactive path selection')
parser.add_argument('--diagnose', action='store_true', help='Scan for issues')
parser.add_argument('--repair', action='store_true', help='Fix issues')
parser.add_argument('--restore', help='Restore from ZIP')
parser.add_argument('--verify', action='store_true', help='Verify installation')
parser.add_argument('--all', action='store_true', help='Diagnose + Repair + Verify')
args = parser.parse_args()

medic = Medic(a0_path=args.path, interactive=args.interactive)

if args.diagnose:
    medic.diagnose()
elif args.repair:
    medic.diagnose()
    medic.repair()
elif args.restore:
    medic.restore(args.restore)
elif args.verify:
    medic.verify()
elif args.all:
    medic.diagnose()
    medic.repair()
    medic.verify()
    medic.report()
else:
    medic.diagnose()
    if medic.issues:
        print('\nRun with --repair to fix, --all for full repair')

if name == 'main':
main()