machineconfig 8.14__py3-none-any.whl → 8.45__py3-none-any.whl

machineconfig/cluster/remote/run_cluster.py

@@ -58,7 +58,7 @@
 
 #         # Execute each job sequentially (replace former List.apply behavior)
 #         # If parallel execution is needed, consider a ThreadPool/ProcessPool
-#         results: List[PathExtended] = [
+#         results: List[Path] = [
 #             ExpensiveComputation.func_single_job(workload_params=job_params, **kwargs)
 #             for job_params in per_job_workload_params
 #         ]

machineconfig/cluster/remote/run_remote.py

@@ -7,7 +7,7 @@
 #     from machineconfig.cluster.remote_machine import RemoteMachine, RemoteMachineConfig, WorkloadParams
 #     from machineconfig.cluster.templates.utils import expensive_function
 #     # from machineconfig.cluster.self_ssh import SelfSSH
-#     data: list[PathExtended] = []
+#     data: list[Path] = []
 #     config = RemoteMachineConfig(
 #         # connection
 #         #        ssh_obj=SelfSSH(),  # overrides ssh_params

machineconfig/cluster/sessions_managers/utils/maker.py

@@ -4,7 +4,7 @@ from typing import Optional, Literal
 from machineconfig.utils.schemas.layouts.layout_types import TabConfig, LayoutConfig
 from pathlib import Path
 
-def get_fire_tab_using_uv(func: FunctionType, tab_weight: int, import_module: bool, uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[TabConfig, Path]:
+def get_fire_tab_using_uv(func: FunctionType, tab_weight: int, import_module: bool, uv_with: Optional[list[str]], uv_project_dir: Optional[str], start_dir: str) -> tuple[TabConfig, Path]:
     from machineconfig.utils.meta import lambda_to_python_script
     if func.__name__ == "<lambda>":
         py_script =  lambda_to_python_script(func,
@@ -16,12 +16,12 @@ def get_fire_tab_using_uv(func: FunctionType, tab_weight: int, import_module: bo
     command_to_run, py_script_path = get_uv_command_executing_python_script(python_script=py_script, uv_with=uv_with, uv_project_dir=uv_project_dir)
     tab_config: TabConfig = {
         "command": command_to_run,
-        "startDir": "$HOME",
+        "startDir": start_dir,
         "tabName": func.__name__,
         "tabWeight": tab_weight
     }
     return tab_config, py_script_path
-def get_fire_tab_using_fire(func: FunctionType, tab_weight: int) -> TabConfig:
+def get_fire_tab_using_fire(func: FunctionType, tab_weight: int, start_dir: str) -> TabConfig:
     import inspect
     from machineconfig.utils.source_of_truth import CONFIG_ROOT
     import platform
@@ -37,7 +37,7 @@ def get_fire_tab_using_fire(func: FunctionType, tab_weight: int) -> TabConfig:
     command_to_run = f"""{wrap_mcfg} fire {path_relative} {func.__name__} """
     tab_config: TabConfig = {
         "command": command_to_run,
-        "startDir": "$HOME",
+        "startDir": start_dir,
         "tabName": func.__name__,
         "tabWeight": tab_weight
     }
@@ -45,20 +45,22 @@ def get_fire_tab_using_fire(func: FunctionType, tab_weight: int) -> TabConfig:
 
 
 
-def make_layout_from_functions(functions: list[FunctionType], functions_weights: Optional[list[int]], import_module: bool, tab_configs: list[TabConfig],
+def make_layout_from_functions(functions: list[FunctionType], functions_weights: Optional[list[int]],
+                               import_module: bool, tab_configs: list[TabConfig],
                                layout_name: str, method: Literal["script", "fire"],
-                               uv_with: Optional[list[str]] = None, uv_project_dir: Optional[str] = None
+                               uv_with: Optional[list[str]], uv_project_dir: Optional[str],
+                               start_dir: str
                                ) -> LayoutConfig:
     tabs2artifacts: list[tuple[TabConfig, list[Path]]] = []
     for a_func, tab_weight in zip(functions, functions_weights or [1]*len(functions)):
         match method:
             case "script":
                 tab_config, artifact_files_1 = get_fire_tab_using_uv(a_func, tab_weight=tab_weight, import_module=import_module,
-                                                                     uv_with=uv_with, uv_project_dir=uv_project_dir
+                                                                     uv_with=uv_with, uv_project_dir=uv_project_dir, start_dir=start_dir
                                                                      )
                 artifact_files = [artifact_files_1]
             case "fire":
-                tab_config = get_fire_tab_using_fire(a_func, tab_weight=tab_weight)
+                tab_config = get_fire_tab_using_fire(a_func, tab_weight=tab_weight, start_dir=start_dir)
                 artifact_files = []
         tabs2artifacts.append((tab_config, artifact_files))
     list_of_tabs = [tab for tab, _ in tabs2artifacts] + tab_configs

machineconfig/cluster/sessions_managers/wt_local.py

@@ -206,7 +206,7 @@ if __name__ == "__main__":
     sample_layout: LayoutConfig = {"layoutName": "TestLayout",
                                    "layoutTabs": [
             {"tabName": "Frontend", "startDir": "~/code", "command": "btm"},
-            {"tabName": "Monitor", "startDir": "~", "command": "lf"}
+            {"tabName": "Monitor", "startDir": "~", "command": "yazi"},
             ]}
     try:
         session_name = sample_layout["layoutName"]

machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -333,7 +333,7 @@ if __name__ == "__main__":
         {
             "layoutName": "DevelopmentEnv",
             "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": "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10"},
             ],

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

@@ -314,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/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, []