comfygit 0.3.1__py3-none-any.whl

comfygit_cli/strategies/rollback.py

@@ -0,0 +1,40 @@
+"""Confirmation strategies for destructive git operations (checkout, reset)."""
+
+
+class InteractiveRollbackStrategy:
+    """Interactive strategy that prompts user to confirm destructive operations."""
+
+    def confirm_destructive_rollback(self, git_changes: bool, workflow_changes: bool) -> bool:
+        """Prompt user to confirm operation that will discard changes.
+
+        Args:
+            git_changes: Whether there are uncommitted git changes in .cec/
+            workflow_changes: Whether there are modified/new/deleted workflows
+
+        Returns:
+            True if user confirms, False otherwise
+        """
+        print("⚠️  This will discard uncommitted changes:")
+        if git_changes:
+            print("  • Git changes in .cec/")
+        if workflow_changes:
+            print("  • Workflow modifications in ComfyUI")
+
+        response = input("\nAre you sure? This cannot be undone. (y/N): ")
+        return response.lower() == 'y'
+
+
+class AutoRollbackStrategy:
+    """Auto-confirm strategy for --yes flag."""
+
+    def confirm_destructive_rollback(self, git_changes: bool, workflow_changes: bool) -> bool:
+        """Always confirm operation (used with --yes flag).
+
+        Args:
+            git_changes: Whether there are uncommitted git changes in .cec/
+            workflow_changes: Whether there are modified/new/deleted workflows
+
+        Returns:
+            Always True
+        """
+        return True

comfygit_cli/utils/__init__.py

@@ -0,0 +1,12 @@
+"""CLI utility functions."""
+
+from .pagination import paginate
+from .progress import create_progress_callback, show_download_stats
+from .civitai_errors import show_civitai_auth_help
+
+__all__ = [
+    "paginate",
+    "create_progress_callback",
+    "show_download_stats",
+    "show_civitai_auth_help",
+]

comfygit_cli/utils/civitai_errors.py

@@ -0,0 +1,9 @@
+"""Civitai error handling utilities."""
+
+
+def show_civitai_auth_help() -> None:
+    """Display helpful message for Civitai authentication errors."""
+    print("\n💡 Civitai API key required")
+    print("   1. Get your API key from: https://civitai.com/user/account")
+    print("   2. Add it to ComfyGit: comfygit config --civitai-key <your-key>")
+    print("   3. Try downloading again")

comfygit_cli/utils/orchestrator.py

@@ -0,0 +1,252 @@
+"""Orchestrator utility functions for CLI commands."""
+
+import json
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+
+def read_orchestrator_pid(metadata_dir: Path) -> Optional[int]:
+    """Read orchestrator PID from file."""
+    pid_file = metadata_dir / ".orchestrator.pid"
+    if not pid_file.exists():
+        return None
+
+    try:
+        return int(pid_file.read_text().strip())
+    except ValueError:
+        return None
+
+
+def _is_process_running(pid: int) -> bool:
+    """Check if a process is running (cross-platform)."""
+    if sys.platform == "win32":
+        import ctypes
+        kernel32 = ctypes.windll.kernel32
+        SYNCHRONIZE = 0x00100000
+        PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+        handle = kernel32.OpenProcess(SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+        if handle:
+            kernel32.CloseHandle(handle)
+            return True
+        return False
+    else:
+        try:
+            os.kill(pid, 0)  # Signal 0 checks if process exists
+            return True
+        except ProcessLookupError:
+            return False
+
+
+def is_orchestrator_running(metadata_dir: Path) -> tuple[bool, Optional[int]]:
+    """Check if orchestrator is running.
+
+    Returns:
+        (is_running, pid) tuple
+    """
+    pid = read_orchestrator_pid(metadata_dir)
+    if not pid:
+        return (False, None)
+
+    if _is_process_running(pid):
+        return (True, pid)
+    else:
+        return (False, pid)  # PID file exists but process is dead
+
+
+def read_switch_status(metadata_dir: Path) -> Optional[dict]:
+    """Read environment switch status."""
+    status_file = metadata_dir / ".switch_status.json"
+    if not status_file.exists():
+        return None
+
+    try:
+        with open(status_file) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return None
+
+
+def safe_write_command(metadata_dir: Path, command: dict) -> None:
+    """
+    Atomically write command file for orchestrator.
+
+    Uses temp file + atomic rename to prevent partial reads.
+    """
+    temp_file = metadata_dir / f".cmd.tmp.{os.getpid()}"
+
+    try:
+        with open(temp_file, 'w') as f:
+            json.dump(command, f)
+
+        # Atomic rename
+        temp_file.replace(metadata_dir / ".cmd")
+    finally:
+        if temp_file.exists():
+            temp_file.unlink()
+
+
+def _kill_process(pid: int, force: bool = False) -> bool:
+    """Kill a process (cross-platform).
+
+    Args:
+        pid: Process ID to kill
+        force: If True, force kill immediately
+
+    Returns:
+        True if kill signal sent, False if process not found
+    """
+    if sys.platform == "win32":
+        import ctypes
+        kernel32 = ctypes.windll.kernel32
+        PROCESS_TERMINATE = 0x0001
+        handle = kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
+        if handle:
+            result = kernel32.TerminateProcess(handle, 1)
+            kernel32.CloseHandle(handle)
+            return bool(result)
+        return False
+    else:
+        try:
+            if force:
+                os.kill(pid, signal.SIGKILL)
+            else:
+                os.kill(pid, signal.SIGTERM)
+            return True
+        except ProcessLookupError:
+            return False
+
+
+def kill_orchestrator_process(pid: int, force: bool = False) -> bool:
+    """Kill orchestrator process.
+
+    Args:
+        pid: Process ID to kill
+        force: If True, kill immediately without graceful shutdown
+
+    Returns:
+        True if process was killed, False if already dead
+    """
+    if not _is_process_running(pid):
+        return False  # Already dead
+
+    if force:
+        return _kill_process(pid, force=True)
+
+    # Try graceful shutdown first
+    _kill_process(pid, force=False)
+
+    # Wait for graceful shutdown (3s)
+    for _ in range(30):
+        time.sleep(0.1)
+        if not _is_process_running(pid):
+            return True  # Process died
+
+    # Still alive, force kill
+    _kill_process(pid, force=True)
+    return True
+
+
+def cleanup_orchestrator_state(metadata_dir: Path, preserve_config: bool = True) -> list[str]:
+    """Clean up orchestrator state files.
+
+    Args:
+        metadata_dir: Metadata directory path
+        preserve_config: If True, keep workspace_config.json
+
+    Returns:
+        List of removed file names
+    """
+    files_to_remove = [
+        ".orchestrator.pid",
+        ".control_port",
+        ".cmd",
+        ".switch_request.json",
+        ".switch_status.json",
+        ".switch.lock",
+        ".startup_state.json",
+    ]
+
+    removed = []
+
+    # Remove specific files
+    for filename in files_to_remove:
+        file_path = metadata_dir / filename
+        if file_path.exists():
+            try:
+                file_path.unlink()
+                removed.append(filename)
+            except OSError:
+                pass
+
+    # Remove temp command files
+    for temp_file in metadata_dir.glob(".cmd.tmp.*"):
+        try:
+            temp_file.unlink()
+            removed.append(temp_file.name)
+        except OSError:
+            pass
+
+    return removed
+
+
+def format_uptime(seconds: float) -> str:
+    """Format uptime in human-readable format."""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        minutes = int(seconds / 60)
+        secs = int(seconds % 60)
+        return f"{minutes}m {secs}s"
+    else:
+        hours = int(seconds / 3600)
+        minutes = int((seconds % 3600) / 60)
+        secs = int(seconds % 60)
+        return f"{hours}h {minutes}m {secs}s"
+
+
+def get_orchestrator_uptime(metadata_dir: Path, pid: int) -> Optional[float]:
+    """Get orchestrator uptime in seconds.
+
+    Reads process start time from /proc on Linux.
+    Returns None if cannot determine.
+    """
+    try:
+        # Linux: read from /proc
+        stat_file = Path(f"/proc/{pid}/stat")
+        if stat_file.exists():
+            stat = stat_file.read_text()
+            # Field 22 is starttime (clock ticks since boot)
+            fields = stat.split()
+            start_ticks = int(fields[21])
+
+            # Get system boot time and clock ticks per second
+            with open("/proc/uptime") as f:
+                uptime_secs = float(f.read().split()[0])
+
+            # Calculate process start time
+            clk_tck = os.sysconf(os.sysconf_names['SC_CLK_TCK'])
+            process_start = start_ticks / clk_tck
+            current_uptime = uptime_secs
+
+            return current_uptime - process_start
+    except (FileNotFoundError, ValueError, OSError):
+        pass
+
+    return None
+
+
+def tail_log_file(log_file: Path, num_lines: int = 50) -> list[str]:
+    """Tail last N lines from log file."""
+    if not log_file.exists():
+        return []
+
+    try:
+        with open(log_file, 'r') as f:
+            lines = f.readlines()
+            return lines[-num_lines:]
+    except IOError:
+        return []

comfygit_cli/utils/pagination.py

@@ -0,0 +1,82 @@
+"""Simple pagination utility for CLI output."""
+
+import sys
+from typing import Callable, TypeVar
+
+T = TypeVar('T')
+
+
+def paginate(
+    items: list[T],
+    render_item: Callable[[T], None],
+    page_size: int = 5,
+    header: str = ""
+) -> None:
+    """Display items with pagination controls.
+
+    Auto-detects if stdout is a TTY. If piped, dumps all items without pagination.
+
+    Args:
+        items: List of items to paginate
+        render_item: Function to render a single item
+        page_size: Number of items per page
+        header: Optional header to display before results
+    """
+    if not items:
+        return
+
+    # Auto-detect: if not a TTY (piped/redirected), dump everything
+    if not sys.stdout.isatty():
+        if header:
+            print(header)
+        for item in items:
+            render_item(item)
+        return
+
+    # Interactive pagination for TTY
+    total_items = len(items)
+    total_pages = (total_items + page_size - 1) // page_size
+    current_page = 0
+
+    while True:
+        # Clear screen and show header
+        print("\033[2J\033[H", end="")  # Clear screen, move to top
+
+        if header:
+            print(header)
+
+        # Calculate page bounds
+        start_idx = current_page * page_size
+        end_idx = min(start_idx + page_size, total_items)
+
+        # Display items for current page
+        for item in items[start_idx:end_idx]:
+            render_item(item)
+
+        # Display pagination controls
+        print(f"\n{'─' * 60}")
+        print(f"Page {current_page + 1}/{total_pages} (showing {start_idx + 1}-{end_idx} of {total_items})")
+
+        # Build prompt based on available navigation
+        options = []
+        if current_page < total_pages - 1:
+            options.append("[n]ext")
+        if current_page > 0:
+            options.append("[p]rev")
+        options.append("[q]uit")
+
+        prompt = f"{' | '.join(options)}: "
+
+        try:
+            choice = input(prompt).lower().strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n")
+            break
+
+        if choice == 'n' and current_page < total_pages - 1:
+            current_page += 1
+        elif choice == 'p' and current_page > 0:
+            current_page -= 1
+        elif choice == 'q':
+            break
+        # Invalid input - just redisplay current page

comfygit_cli/utils/progress.py

@@ -0,0 +1,128 @@
+"""Progress display utilities for downloads and model scanning."""
+
+from collections.abc import Callable
+
+from comfygit_core.analyzers.model_scanner import ModelScanProgress, ScanResult
+from comfygit_core.models.shared import ModelWithLocation
+from comfygit_core.models.workflow import BatchDownloadCallbacks
+from comfygit_core.utils.common import format_size
+
+
+def create_progress_callback() -> Callable[[int, int | None], None]:
+    """Create a reusable progress callback for model downloads.
+
+    Returns:
+        Callback function that displays download progress
+    """
+    def progress_callback(downloaded: int, total: int | None):
+        """Display progress bar using carriage return."""
+        downloaded_mb = downloaded / (1024 * 1024)
+        if total:
+            total_mb = total / (1024 * 1024)
+            pct = (downloaded / total) * 100
+            print(f"\rDownloading... {downloaded_mb:.1f} MB / {total_mb:.1f} MB ({pct:.0f}%)", end='', flush=True)
+        else:
+            print(f"\rDownloading... {downloaded_mb:.1f} MB", end='', flush=True)
+
+    return progress_callback
+
+
+def show_download_stats(model: ModelWithLocation | None) -> None:
+    """Display statistics after successful download.
+
+    Args:
+        model: Downloaded and indexed model
+    """
+    if not model:
+        return
+    size_str = format_size(model.file_size)
+    print(f"✓ Downloaded and indexed: {model.relative_path}")
+    print(f"  Size: {size_str}")
+    print(f"  Hash: {model.hash}")
+
+
+def create_batch_download_callbacks() -> BatchDownloadCallbacks:
+    """Create CLI callbacks for batch downloads with terminal output.
+
+    Returns:
+        BatchDownloadCallbacks configured for CLI rendering
+    """
+    def on_batch_start(count: int) -> None:
+        print(f"\n⬇️  Downloading {count} model(s)...")
+
+    def on_file_start(name: str, idx: int, total: int) -> None:
+        print(f"\n[{idx}/{total}] {name}")
+
+    def on_file_complete(name: str, success: bool, error: str | None) -> None:
+        if success:
+            print("  ✓ Complete")
+        else:
+            print(f"  ✗ Failed: {error}")
+
+    def on_batch_complete(success: int, total: int) -> None:
+        if success == total:
+            print(f"\n✅ Downloaded {total} model(s)")
+        elif success > 0:
+            print(f"\n⚠️  Downloaded {success}/{total} models (some failed)")
+        else:
+            print(f"\n❌ All downloads failed (0/{total})")
+
+    return BatchDownloadCallbacks(
+        on_batch_start=on_batch_start,
+        on_file_start=on_file_start,
+        on_file_progress=create_progress_callback(),
+        on_file_complete=on_file_complete,
+        on_batch_complete=on_batch_complete
+    )
+
+
+class ModelSyncProgress(ModelScanProgress):
+    """CLI progress display for model scanning with conditional visibility.
+
+    Shows progress bar only when models are being processed (not just scanned).
+    """
+
+    def __init__(self):
+        self.total_files = 0
+        self.shown = False
+
+    def on_scan_start(self, total_files: int) -> None:
+        """Called when scan starts."""
+        self.total_files = total_files
+        # Show initial message - we'll update it as we go
+        if total_files > 0:
+            print("🔄 Syncing model index...", end='', flush=True)
+            self.shown = True
+
+    def on_file_processed(self, current: int, total: int, filename: str) -> None:
+        """Update progress bar."""
+        if self.shown and total > 100:  # Only show detailed progress for large directories
+            print(f"\r🔄 Syncing model index... {current}/{total} files", end='', flush=True)
+
+    def on_scan_complete(self, result: ScanResult) -> None:
+        """Show summary only if there were changes."""
+        has_changes = result.added_count > 0 or result.updated_count > 0
+
+        if self.shown:
+            if has_changes:
+                # Clear progress line and show summary
+                print("\r\033[K", end='')  # Clear line (carriage return + clear to end of line)
+                changes = []
+                if result.added_count > 0:
+                    changes.append(f"{result.added_count} added")
+                if result.updated_count > 0:
+                    changes.append(f"{result.updated_count} updated")
+                print(f"✓ Model index synced: {', '.join(changes)}")
+            else:
+                # Clear the line completely if no changes
+                print("\r\033[K", end='', flush=True)  # Clear line completely
+                # Don't print anything - silent when no changes
+
+
+def create_model_sync_progress() -> ModelSyncProgress:
+    """Create progress callback for model index syncing.
+
+    Returns:
+        ModelSyncProgress instance that conditionally displays progress
+    """
+    return ModelSyncProgress()