prole/docs/PROLE-HOME-DIRECTORY.md

Prole Home Directory Structure

Overview

The Prole Installer creates and uses $HOME/.prole/ for writable storage when running from a packaged binary. This is necessary because PyInstaller extracts resources to a read-only temporary directory.

Directory Structure

$HOME/.prole/
├── build/               # Docker build contexts
│   └── prole-db/       # PostgreSQL Docker build
│       ├── Dockerfile
│       ├── conf/
│       └── ...
└── scan/               # Network scan output and cache
    └── (scan results, temporary files)

Purpose of Each Directory

build/

Purpose: Writable location for Docker build contexts

Why: PyInstaller extracts resources to /tmp/_MEIxxxxxx/ which is read-only. Docker requires a writable build context directory to create images.

Usage:

prole_home = Path.home() / ".prole"
build_dir = prole_home / "build" / "prole-db"
build_dir.mkdir(parents=True, exist_ok=True)

# Copy build context from embedded resources
source_dir = get_resource_path("prole-db")
shutil.copytree(source_dir, build_dir)

# Docker build
subprocess.Popen(['docker', 'build', '-t', 'prole-db:TAG', '.'], cwd=build_dir)

Contents:

• Complete copy of prole-db/ directory
• Dockerfile and all dependencies
• Refreshed on each build (old content removed)

Size: ~1-5 MB

scan/

Purpose: Writable working directory for network scan operations

Why: The prole-scan binary may need to write output files, cache data, or store temporary results. Running from a read-only directory causes failures.

Usage:

prole_home = Path.home() / ".prole"
scan_dir = prole_home / "scan"
scan_dir.mkdir(parents=True, exist_ok=True)

# Run scan with writable cwd
subprocess.Popen([str(scan_binary)], cwd=str(scan_dir))

Contents:

• Network scan results (temporary)
• Ollama API interaction cache
• Any intermediate files created by prole-scan

Size: Varies, typically < 1 MB

Creation and Cleanup

Automatic Creation

All directories are created automatically when needed:

# Build directory
(Path.home() / ".prole" / "build" / "prole-db").mkdir(parents=True, exist_ok=True)

# Scan directory
(Path.home() / ".prole" / "scan").mkdir(parents=True, exist_ok=True)

Manual Cleanup

To remove all Prole working directories:

rm -rf ~/.prole

Or from Python:

import shutil
from pathlib import Path

prole_home = Path.home() / ".prole"
if prole_home.exists():
    shutil.rmtree(prole_home)

Automatic Cleanup (Future)

Consider adding cleanup options to the installer:

def cleanup_prole_home():
    """Clean up .prole working directories."""
    prole_home = Path.home() / ".prole"
    if prole_home.exists():
        # Keep or remove based on user preference
        if messagebox.askyesno("Cleanup", "Remove temporary files?"):
            shutil.rmtree(prole_home)

Disk Space

Expected Usage

Directory	Size	When Created	Persistent
build/prole-db/	1-5 MB	First Docker build	Yes
scan/	< 1 MB	First network scan	Yes
Total	~2-6 MB	On first use	Yes

Growth

• build/ – Overwritten on each build, doesn't grow
• scan/ – May accumulate cache files over time

Troubleshooting

Permission Errors

Error: Permission denied creating .prole directory

Cause: Home directory not writable

Solution:

ls -ld ~
chmod u+w ~

Disk Space Issues

Error: No space left on device

Cause: Disk full

Solution:

df -h ~
rm -rf ~/.prole  # Free up space

Stale Build Context

Issue: Docker build uses old files

Solution:

# Build directory is refreshed automatically
if build_dir.exists():
    shutil.rmtree(build_dir)
shutil.copytree(source_dir, build_dir)

Security Considerations

File Permissions

The .prole directory inherits user's home directory permissions:

ls -ld ~/.prole
# drwxr-xr-x  user  group  ~/.prole

Only the user should have write access.

Sensitive Data

Avoid storing sensitive data in .prole/:

• ✓ Build contexts (public)
• ✓ Scan results (network info, semi-sensitive)
• ✗ Passwords, keys, credentials

Cleanup on Uninstall

If distributing the installer, consider:

1. Document cleanup:

   To completely remove Prole:
   1. Delete the app: rm -rf /Applications/Prole\ Installer.app
   2. Clean up data: rm -rf ~/.prole
   

2. Provide uninstall script:

   #!/bin/bash
   # uninstall-prole.sh
   rm -rf /Applications/Prole\ Installer.app
   rm -rf ~/.prole
   echo "Prole uninstalled"
   

Related Issues

Docker Build Hang

Problem: Docker build hangs when running from packaged binary

Solution: Copy build context to ~/.prole/build/prole-db/

See: DOCKER-BUILD-FIX.md

Network Scan Failure

Problem: Network scan fails to make API calls from packaged binary

Solution: Run scan with cwd=~/.prole/scan

Reason: Scan binary needs writable directory for output/cache

Implementation Details

Code Location

Build directory creation: install.py, run_db_build() method (line ~1791)

prole_home = Path.home() / ".prole"
build_dir = prole_home / "build" / "prole-db"
build_dir.mkdir(parents=True, exist_ok=True)

Scan directory creation: install.py, network scan worker (line ~1102)

prole_home = Path.home() / ".prole"
scan_dir = prole_home / "scan"
scan_dir.mkdir(parents=True, exist_ok=True)

Resource Path Resolution

Both use get_resource_path() to find embedded resources:

def get_resource_path(relative_path):
    """Get absolute path to resource, works for dev and for PyInstaller."""
    try:
        base_path = Path(sys._MEIPASS)  # PyInstaller temp dir
    except AttributeError:
        base_path = PROJECT_ROOT  # Running from source

    return base_path / relative_path

Future Enhancements

Persistent Cache

Store network scan results between runs:

scan_cache = Path.home() / ".prole" / "scan" / "cache.json"
if scan_cache.exists():
    # Load previous scan
    results = json.loads(scan_cache.read_text())
else:
    # Run new scan
    results = run_scan()
    scan_cache.write_text(json.dumps(results))

Build Artifacts

Store built Docker images as tarballs:

image_cache = Path.home() / ".prole" / "build" / "prole-db-TAG.tar"
if not image_cache.exists():
    # Build and save
    subprocess.run(['docker', 'build', '-t', 'prole-db:TAG', '.'])
    subprocess.run(['docker', 'save', '-o', str(image_cache), 'prole-db:TAG'])
else:
    # Load cached image
    subprocess.run(['docker', 'load', '-i', str(image_cache)])

Configuration Storage

Store user preferences:

config_file = Path.home() / ".prole" / "config.json"
config = {
    'cluster_env': 'development',
    'kerberos_enabled': False,
    'last_scan': '2025-01-19',
}
config_file.write_text(json.dumps(config, indent=2))

Summary

The ~/.prole/ directory provides:

• ✓ Writable storage for packaged binary operations
• ✓ Separate from extracted read-only resources
• ✓ User-specific, secure location
• ✓ Easy to clean up manually
• ✓ Small disk footprint (< 10 MB)

This architecture ensures the installer works correctly whether running from source or from a PyInstaller package.