machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/cluster/sessions_managers/wt_utils/wt_helpers.py

@@ -0,0 +1,199 @@
+import subprocess
+import random
+import string
+import json
+import shlex
+import logging
+from typing import Any
+from pathlib import Path
+
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+
+logger = logging.getLogger(__name__)
+
+POWERSHELL_CMD = "powershell" if __import__("platform").system().lower() == "windows" else "pwsh"
+
+
+def generate_random_suffix(length: int) -> str:
+    """Generate a random string suffix for unique PowerShell script names."""
+    return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
+
+
+def parse_command(command: str) -> tuple[str, list[str]]:
+    try:
+        parts = shlex.split(command)
+        if not parts:
+            raise ValueError("Empty command provided")
+        return parts[0], parts[1:] if len(parts) > 1 else []
+    except ValueError as e:
+        logger.error(f"Error parsing command '{command}': {e}")
+        parts = command.split()
+        return parts[0] if parts else "", parts[1:] if len(parts) > 1 else []
+
+
+def escape_for_wt(text: str) -> str:
+    """Escape text for use in Windows Terminal commands."""
+    text = text.replace('"', '""')
+    if " " in text or ";" in text or "&" in text or "|" in text:
+        return f'"{text}"'
+    return text
+
+
+def validate_layout_config(layout_config: LayoutConfig) -> None:
+    """Validate layout configuration format and content."""
+    if not layout_config["layoutTabs"]:
+        raise ValueError("Layout must contain at least one tab")
+    for tab in layout_config["layoutTabs"]:
+        if not tab["tabName"].strip():
+            raise ValueError(f"Invalid tab name: {tab['tabName']}")
+        if not tab["command"].strip():
+            raise ValueError(f"Invalid command for tab '{tab['tabName']}': {tab['command']}")
+        if not tab["startDir"].strip():
+            raise ValueError(f"Invalid startDir for tab '{tab['tabName']}': {tab['startDir']}")
+
+
+def generate_wt_command_string(layout_config: LayoutConfig, window_name: str) -> str:
+    """Generate complete Windows Terminal command string."""
+    command_parts = []
+    
+    for i, tab in enumerate(layout_config["layoutTabs"]):
+        is_first = i == 0
+        
+        if is_first:
+            tab_parts = ["wt", "-w", escape_for_wt(window_name)]
+        else:
+            tab_parts = ["new-tab"]
+        
+        tab_name = tab["tabName"]
+        cwd = tab["startDir"]
+        command = tab["command"]
+        
+        if cwd.startswith("~/"):
+            cwd = cwd.replace("~/", f"{Path.home()}/")
+        elif cwd == "~":
+            cwd = str(Path.home())
+        
+        tab_parts.extend(["-d", escape_for_wt(cwd)])
+        tab_parts.extend(["--title", escape_for_wt(tab_name)])
+        tab_parts.append("--")
+        
+        # Split the command into arguments
+        command_args = shlex.split(command)
+        tab_parts.extend(command_args)
+        
+        command_parts.append(" ".join(tab_parts))
+    
+    return " `; ".join(command_parts)
+
+
+def check_wt_session_status(session_name: str) -> dict[str, Any]:
+    try:
+        ps_script = """
+try {
+    $wtProcesses = Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue
+    if ($wtProcesses) {
+        $processInfo = @()
+        $wtProcesses | ForEach-Object {
+            $info = @{
+                "Id" = $_.Id
+                "ProcessName" = $_.ProcessName
+                "StartTime" = $_.StartTime.ToString()
+            }
+            $processInfo += $info
+        }
+        $processInfo | ConvertTo-Json -Depth 2
+    }
+} catch {
+    # No Windows Terminal processes found
+}
+"""
+
+        result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
+
+        if result.returncode == 0:
+            output = result.stdout.strip()
+            if output and output != "":
+                try:
+                    processes = json.loads(output)
+                    if not isinstance(processes, list):
+                        processes = [processes]
+
+                    return {"wt_running": True, "session_exists": len(processes) > 0, "session_name": session_name, "all_windows": processes, "session_windows": processes}
+                except Exception as e:
+                    return {"wt_running": True, "session_exists": False, "error": f"Failed to parse process info: {e}", "session_name": session_name}
+            else:
+                return {"wt_running": False, "session_exists": False, "session_name": session_name, "all_windows": []}
+        else:
+            return {"wt_running": False, "error": result.stderr, "session_name": session_name}
+
+    except subprocess.TimeoutExpired:
+        return {"wt_running": False, "error": "Timeout while checking Windows Terminal processes", "session_name": session_name}
+    except FileNotFoundError:
+        return {"wt_running": False, "error": f"PowerShell ({POWERSHELL_CMD}) not found in PATH", "session_name": session_name}
+    except Exception as e:
+        return {"wt_running": False, "error": str(e), "session_name": session_name}
+
+
+def check_command_status(tab_name: str, layout_config: LayoutConfig) -> dict[str, Any]:
+    """Check if a command is running by looking for processes."""
+    tab_config = None
+    for tab in layout_config["layoutTabs"]:
+        if tab["tabName"] == tab_name:
+            tab_config = tab
+            break
+
+    if tab_config is None:
+        return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "pid": None, "command": None}
+
+    command = tab_config["command"]
+
+    try:
+        primary_cmd = command.split()[0] if command.strip() else ""
+        if not primary_cmd:
+            return {"status": "error", "error": "Empty command", "running": False, "command": command, "tab_name": tab_name}
+
+        ps_script = f"""
+try {{
+    $processes = Get-Process -Name '{primary_cmd}' -ErrorAction SilentlyContinue
+    if ($processes) {{
+        $processes | ForEach-Object {{
+            $procInfo = @{{
+                "pid" = $_.Id
+                "name" = $_.ProcessName
+                "start_time" = $_.StartTime.ToString()
+            }}
+            Write-Output ($procInfo | ConvertTo-Json -Compress)
+        }}
+    }}
+}} catch {{
+    # No processes found or other error
+}}
+"""
+
+        result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
+
+        if result.returncode == 0:
+            output_lines = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
+            matching_processes = []
+
+            for line in output_lines:
+                if line.startswith("{") and line.endswith("}"):
+                    try:
+                        proc_info = json.loads(line)
+                        matching_processes.append(proc_info)
+                    except json.JSONDecodeError:
+                        continue
+
+            if matching_processes:
+                return {"status": "running", "running": True, "processes": matching_processes, "command": command, "tab_name": tab_name}
+            else:
+                return {"status": "not_running", "running": False, "processes": [], "command": command, "tab_name": tab_name}
+        else:
+            return {"status": "error", "error": f"Command failed: {result.stderr}", "running": False, "command": command, "tab_name": tab_name}
+
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout checking command status for tab '{tab_name}'")
+        return {"status": "timeout", "error": "Timeout checking process status", "running": False, "command": command, "tab_name": tab_name}
+    except Exception as e:
+        logger.error(f"Error checking command status for tab '{tab_name}': {e}")
+        return {"status": "error", "error": str(e), "running": False, "command": command, "tab_name": tab_name}

machineconfig/cluster/sessions_managers/zellij_local.py

@@ -206,7 +206,7 @@ if __name__ == "__main__":
     # Example usage with new schema
     sample_layout: LayoutConfig = {
         "layoutName": "SampleBots",
-        "layoutTabs": [{"tabName": "Explorer", "startDir": "~/code", "command": "lf"}, {"tabName": "🤖Bot2", "startDir": "~", "command": "cmatrix"}, {"tabName": "📊Monitor", "startDir": "~", "command": "htop"}, {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"}],
+        "layoutTabs": [{"tabName": "Explorer", "startDir": "~/code", "command": "yazi"}, {"tabName": "🤖Bot2", "startDir": "~", "command": "cmatrix"}, {"tabName": "📊Monitor", "startDir": "~", "command": "htop"}, {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"}],
     }
     try:
         # Create layout using the generator with new design

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -276,7 +276,9 @@ class ZellijLocalManager:
                 print(f"📊 Quick Summary: {global_summary['running_commands']}/{global_summary['total_commands']} commands running across {global_summary['healthy_sessions']}/{global_summary['total_sessions']} sessions")
 
         logger.info(f"Starting monitoring routine with {wait_ms}ms intervals")
-        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=logger)
+        from machineconfig.utils.scheduler import LoggerTemplate
+        from typing import cast
+        sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=cast(LoggerTemplate, logger))
         sched.run()
 
     def save(self, session_id: Optional[str]) -> str:
@@ -312,7 +314,7 @@ if __name__ == "__main__":
         {
             "layoutName": "Development",
             "layoutTabs": [
-                {"tabName": "🚀Frontend", "startDir": "~/code/myapp/frontend", "command": "npm run dev"},
+                {"tabName": "🚀Frontend", "startDir": "~/code/myapp/frontend", "command": "bun run dev"},
                 {"tabName": "⚙️Backend", "startDir": "~/code/myapp/backend", "command": "python manage.py runserver"},
                 {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
             ],

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -88,8 +88,9 @@ class ZellijSessionManager:
                 # Print statuses
                 for i, status in enumerate(statuses):
                     print(f"Manager {i}: {status}")
-
-        sched = Scheduler(routine=routine, wait_ms=60_000, logger=logger)
+        from machineconfig.utils.scheduler import LoggerTemplate
+        from typing import cast
+        sched = Scheduler(routine=routine, wait_ms=60_000, logger=cast(LoggerTemplate, logger))
         sched.run()
 
     def save(self, session_id: Optional[str]) -> str:

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -53,7 +53,7 @@ class ProcessMonitor:
         command = tab_config["command"]
         try:
             check_script = self._create_process_check_script(command)
-            remote_cmd = f"$HOME/.local/bin devops self run-python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/.local/bin devops self python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
             if result.returncode == 0:
                 try:
@@ -139,7 +139,7 @@ if __name__ == "__main__":
             check_timestamp = timestamp_result.stdout.strip() if timestamp_result.returncode == 0 else "unknown"
 
             check_script = self._create_fresh_check_script(command)
-            remote_cmd = f"$HOME/.local/bin/devops self run-python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/.local/bin/devops self python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
 
             if result.returncode == 0:

machineconfig/jobs/installer/checks/check_installations.py

@@ -0,0 +1,133 @@
+"""
+Check Installations
+===================
+
+This module scans installed applications using VirusTotal and generates a safety report.
+It also provides functionality to download and install pre-checked applications.
+"""
+
+import csv
+import platform
+from datetime import datetime
+from typing import Optional
+
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+
+from machineconfig.jobs.installer.checks.install_utils import upload_app
+from machineconfig.jobs.installer.checks.report_utils import AppData, generate_markdown_report
+from machineconfig.jobs.installer.checks.vt_utils import get_vt_client, scan_file
+from machineconfig.utils.installer_utils.installer_runner import get_installed_cli_apps
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.source_of_truth import CONFIG_ROOT, INSTALL_VERSION_ROOT
+
+# Constants
+APP_SUMMARY_PATH = CONFIG_ROOT.joinpath(f"profile/records/{platform.system().lower()}/apps_summary_report.csv")
+
+console = Console()
+
+def main() -> None:
+    """Main execution function."""
+    console.rule("[bold blue]MachineConfig Installation Checker[/bold blue]")
+
+    # 1. Gather Installed Apps
+    with console.status("[bold green]Gathering installed applications...[/bold green]"):
+        apps_paths = get_installed_cli_apps()
+        # Filter and find versions
+        # This part mimics the original logic but simplifies it
+        # We assume apps_paths contains PathExtended objects
+        
+        # Find version files
+        install_version_root_ext = PathExtended(INSTALL_VERSION_ROOT)
+        version_files = list(install_version_root_ext.search()) if install_version_root_ext.exists() else []
+        
+        apps_to_scan: list[tuple[PathExtended, Optional[str]]] = []
+        
+        for app_path in apps_paths:
+            # Try to find version
+            version = None
+            # Simple matching logic: check if any version file matches the app name
+            # This is a heuristic from the original code
+            matching_versions = [v for v in version_files if v.stem == app_path.stem]
+            if matching_versions:
+                version = matching_versions[0].read_text(encoding="utf-8").strip()
+            
+            apps_to_scan.append((app_path, version))
+
+    console.print(f"[green]Found {len(apps_to_scan)} applications to check.[/green]")
+
+    # 2. Scan Apps with VirusTotal
+    app_data_list: list[AppData] = []
+    
+    try:
+        client = get_vt_client()
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            console=console
+        ) as progress:
+            scan_task = progress.add_task("[cyan]Scanning apps...", total=len(apps_to_scan))
+            
+            for app_path, version in apps_to_scan:
+                progress.update(scan_task, description=f"Scanning {app_path.name}...")
+                
+                positive_pct, _ = scan_file(app_path, client, progress, scan_task)
+                
+                # Upload if safe (optional, based on original code logic which uploaded everything?)
+                # Original code uploaded everything.
+                progress.update(scan_task, description=f"Uploading {app_path.name}...")
+                app_url = upload_app(app_path) or ""
+                
+                app_data_list.append({
+                    "app_name": app_path.stem,
+                    "version": version,
+                    "positive_pct": positive_pct,
+                    "scan_time": datetime.now().strftime("%Y-%m-%d %H:%M"),
+                    "app_path": app_path.collapseuser(strict=False).as_posix(),
+                    "app_url": app_url
+                })
+                
+                progress.advance(scan_task)
+
+    except FileNotFoundError as e:
+        console.print(f"[bold red]{e}[/bold red]")
+        console.print("[yellow]Skipping scanning due to missing credentials.[/yellow]")
+        # Fallback: just list apps without scan results
+        for app_path, version in apps_to_scan:
+             app_data_list.append({
+                "app_name": app_path.stem,
+                "version": version,
+                "positive_pct": None,
+                "scan_time": datetime.now().strftime("%Y-%m-%d %H:%M"),
+                "app_path": app_path.collapseuser(strict=False).as_posix(),
+                "app_url": ""
+            })
+    except Exception as e:
+        console.print(f"[bold red]An unexpected error occurred during scanning: {e}[/bold red]")
+
+    # 3. Generate Reports
+    if app_data_list:
+        # CSV Report
+        APP_SUMMARY_PATH.parent.mkdir(parents=True, exist_ok=True)
+        csv_path = APP_SUMMARY_PATH.with_suffix(".csv")
+        
+        with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
+            fieldnames = list(app_data_list[0].keys())
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(app_data_list)
+        
+        console.print(f"[green]CSV report saved to: {csv_path}[/green]")
+
+        # Markdown Report
+        md_path = APP_SUMMARY_PATH.with_suffix(".md")
+        generate_markdown_report(app_data_list, md_path)
+        console.print(f"[green]Markdown report saved to: {md_path}[/green]")
+
+
+
+if __name__ == '__main__':
+    main()

machineconfig/jobs/installer/checks/install_utils.py

@@ -0,0 +1,132 @@
+"""
+Installation Utilities
+======================
+
+This module provides functionality to download and install pre-checked applications.
+"""
+
+import csv
+import platform
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Any, Optional
+
+import gdown
+from rich.console import Console
+
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.source_of_truth import CONFIG_ROOT
+
+# Constants
+APP_SUMMARY_PATH = CONFIG_ROOT.joinpath(f"profile/records/{platform.system().lower()}/apps_summary_report.csv")
+CLOUD_STORAGE_NAME = "gdw"  # Default cloud storage name for rclone
+
+console = Console()
+
+def upload_app(path: PathExtended) -> Optional[str]:
+    """Uploads the app to cloud storage and returns the shareable link."""
+    try:
+        # Using PathExtended.to_cloud
+        # Assuming 'gdw' is the configured remote in rclone
+        link_path = path.to_cloud(CLOUD_STORAGE_NAME, rel2home=True, share=True, os_specific=True, verbose=False)
+        if link_path:
+             return str(link_path)
+        return None
+    except Exception as e:
+        console.print(f"[red]Failed to upload {path}: {e}[/red]")
+        return None
+
+def download_google_drive_file(url: str) -> PathExtended:
+    """Downloads a file from Google Drive using gdown."""
+    try:
+        # Extract ID from URL
+        # Assuming URL format like https://drive.google.com/file/d/FILE_ID/view or similar
+        # or https://drive.google.com/uc?id=FILE_ID
+        if "id=" in url:
+            file_id = url.split("id=")[1].split("&")[0]
+        elif "/d/" in url:
+            file_id = url.split("/d/")[1].split("/")[0]
+        else:
+            # Fallback to gdown's auto detection or just pass URL
+            file_id = url
+
+        # Create a temporary directory for download
+        output_dir = PathExtended.tmpdir(prefix="gdown_")
+        # gdown.download returns the output filename
+        output_file = gdown.download(id=file_id, output=str(output_dir) + "/", quiet=False, fuzzy=True)
+        
+        if not output_file:
+            raise ValueError(f"Download failed for {url}")
+            
+        return PathExtended(output_file)
+    except Exception as e:
+        raise RuntimeError(f"Failed to download from Google Drive: {e}") from e
+
+def install_cli_app(app_url: str) -> bool:
+    """Downloads and installs a CLI app."""
+    try:
+        if not app_url:
+            return False
+            
+        exe_path = download_google_drive_file(app_url)
+        console.print(f"[green]Downloaded {exe_path.name}[/green]")
+        
+        system = platform.system().lower()
+        if system in ["linux", "darwin"]:
+            exe_path.chmod(0o755) # Make executable
+            # Move to local bin (requires user to have write access or sudo, which we can't easily do here without interaction)
+            # Using ~/.local/bin is safer
+            install_path = Path.home() / ".local/bin"
+            install_path.mkdir(parents=True, exist_ok=True)
+            target = install_path / exe_path.name
+            exe_path.rename(target)
+            console.print(f"[green]Installed to {target}[/green]")
+        elif system == "windows":
+            install_path = Path.home() / "AppData/Local/Microsoft/WindowsApps"
+            install_path.mkdir(parents=True, exist_ok=True)
+            target = install_path / exe_path.name
+            # Use shutil.move or PathExtended.move
+            exe_path.move(path=target, overwrite=True)
+            console.print(f"[green]Installed to {target}[/green]")
+        
+        return True
+    except Exception as e:
+        console.print(f"[red]Failed to install app from {app_url}: {e}[/red]")
+        return False
+
+def load_summary_report() -> list[dict[str, Any]]:
+    """Loads the summary report from CSV."""
+    if APP_SUMMARY_PATH.exists():
+        with open(APP_SUMMARY_PATH, 'r', encoding='utf-8') as csvfile:
+            reader = csv.DictReader(csvfile)
+            return list(reader)
+    else:
+        console.print(f"[yellow]Warning: Summary report not found at {APP_SUMMARY_PATH}[/yellow]")
+        return []
+
+def download_safe_apps(name: str = "essentials") -> None:
+    """Downloads and installs safe apps."""
+    data = load_summary_report()
+    if not data:
+        console.print("[red]No app data available to install.[/red]")
+        return
+
+    apps_to_install = []
+    if name == "essentials":
+        # Install all available apps in the report? Or filter?
+        # Original code installed all if name="essentials" (implied by logic)
+        apps_to_install = [item['app_url'] for item in data if item.get('app_url')]
+    else:
+        apps_to_install = [item['app_url'] for item in data if item.get('app_name') == name and item.get('app_url')]
+
+    if not apps_to_install:
+        console.print(f"[yellow]No apps found to install for '{name}'.[/yellow]")
+        return
+
+    console.print(f"[bold]Installing {len(apps_to_install)} apps...[/bold]")
+    
+    with ThreadPoolExecutor(max_workers=5) as executor:
+        results = list(executor.map(install_cli_app, apps_to_install))
+    
+    success_count = sum(results)
+    console.print(f"[bold green]Successfully installed {success_count}/{len(apps_to_install)} apps.[/bold green]")

machineconfig/jobs/installer/checks/report_utils.py

@@ -0,0 +1,39 @@
+"""
+Report Utilities
+================
+
+This module provides functionality to generate reports for installed applications.
+"""
+
+from pathlib import Path
+from typing import Optional, TypedDict
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+class AppData(TypedDict):
+    app_name: str
+    version: Optional[str]
+    positive_pct: Optional[float]
+    scan_time: str
+    app_path: str
+    app_url: str
+
+def generate_markdown_report(data: list[AppData], output_path: Path) -> None:
+    """Generates a Markdown table from the app data."""
+    if not data:
+        return
+
+    keys = list(data[0].keys())
+    header = "| " + " | ".join(key.replace("_", " ").title() for key in keys) + " |"
+    separator = "| " + " | ".join("---" for _ in keys) + " |"
+    rows = []
+    for row in data:
+        # Fix: row is a dict, keys are strings.
+        row_values = [str(row.get(key, '')) for key in keys]
+        rows.append("| " + " | ".join(row_values) + " |")
+    
+    content = "\n".join([header, separator] + rows)
+    output_path.write_text(content, encoding="utf-8")
+    console.print(Panel(content, title="Safety Report Summary", expand=False))

machineconfig/jobs/installer/checks/vt_utils.py

@@ -0,0 +1,89 @@
+"""
+VirusTotal Utilities
+====================
+
+This module provides functionality to interact with VirusTotal API.
+"""
+
+import time
+from pathlib import Path
+from typing import Any, Optional, TypedDict
+
+import vt
+from rich.progress import Progress, TaskID
+
+# Constants
+VT_TOKEN_PATH = Path.home().joinpath("dotfiles/creds/tokens/virustotal")
+
+class ScanResult(TypedDict):
+    result: Optional[str]
+    category: str
+
+def get_vt_client() -> vt.Client:
+    """Retrieves the VirusTotal client using the token from the credentials file."""
+    if not VT_TOKEN_PATH.exists():
+        raise FileNotFoundError(f"VirusTotal token not found at {VT_TOKEN_PATH}")
+    
+    token = VT_TOKEN_PATH.read_text(encoding="utf-8").split("\n")[0].strip()
+    return vt.Client(token)
+
+def scan_file(path: Path, client: vt.Client, progress: Optional[Progress] = None, task_id: Optional[TaskID] = None) -> tuple[Optional[float], list[Any]]:
+    """
+    Scans a file using VirusTotal.
+    
+    Args:
+        path: Path to the file to scan.
+        client: VirusTotal client instance.
+        progress: Optional Rich progress bar.
+        task_id: Optional Task ID for the progress bar.
+
+    Returns:
+        A tuple containing the positive percentage (0-100) and the list of result details.
+        Returns (None, []) if scanning fails or file is skipped.
+    """
+    if path.is_dir():
+        if progress and task_id:
+            progress.console.print(f"[yellow]📁 Skipping directory: {path}[/yellow]")
+        return None, []
+
+    try:
+        with open(path, "rb") as f:
+            analysis = client.scan_file(f)
+        
+        repeat_counter = 0
+        while True:
+            try:
+                anal = client.get_object("/analyses/{}", analysis.id)
+                if anal.status == "completed":
+                    break
+            except Exception as e:
+                repeat_counter += 1
+                if repeat_counter > 3:
+                    raise ValueError(f"❌ Error scanning {path}: {e}") from e
+                if progress and task_id:
+                    progress.console.print(f"[red]⚠️  Error scanning {path}, retrying... ({repeat_counter}/3)[/red]")
+                time.sleep(5)
+            
+            time.sleep(10) # Wait before checking status again
+
+        # Process results
+        results_data = list(anal.results.values())
+        malicious = []
+        for result_item in results_data:
+            result_dict = result_item.__dict__ if hasattr(result_item, '__dict__') else {
+                'result': getattr(result_item, 'result', None),
+                'category': getattr(result_item, 'category', 'unknown')
+            }
+
+            if result_dict.get('result') is None and result_dict.get('category') in ["undetected", "type-unsupported", "failure", "timeout", "confirmed-timeout"]:
+                continue
+            
+            malicious.append(result_item)
+
+        positive_pct = round(len(malicious) / len(results_data) * 100, 1) if results_data else 0.0
+        return positive_pct, results_data
+
+    except Exception as e:
+        if progress and task_id:
+            progress.console.print(f"[bold red]❌ Failed to scan {path}: {e}[/bold red]")
+        return None, []