machineconfig 5.21__py3-none-any.whl → 5.23__py3-none-any.whl

machineconfig/scripts/python/devops_status.py

@@ -0,0 +1,521 @@
+"""Machine Status Display - Comprehensive system and configuration overview"""
+
+import platform
+import shutil
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH, LIBRARY_ROOT
+
+
+console = Console()
+
+
+def _check_system_info() -> dict[str, str]:
+    """Gather basic system information."""
+    import socket
+    import os
+
+    return {
+        "hostname": socket.gethostname(),
+        "system": platform.system(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor() or "Unknown",
+        "python_version": platform.python_version(),
+        "user": os.getenv("USER") or os.getenv("USERNAME") or "Unknown",
+    }
+
+
+def _check_shell_profile_status() -> dict[str, Any]:
+    """Check shell profile configuration status."""
+    from machineconfig.profile.shell import get_shell_profile_path
+
+    try:
+        profile_path = get_shell_profile_path()
+        profile_exists = profile_path.exists()
+        profile_content = profile_path.read_text(encoding="utf-8") if profile_exists else ""
+
+        system_name = platform.system()
+        if system_name == "Windows":
+            init_script = PathExtended(LIBRARY_ROOT).joinpath("settings/shells/pwsh/init.ps1")
+            init_script_copy = PathExtended(CONFIG_PATH).joinpath("profile/init.ps1").collapseuser()
+            source_reference = f". {str(init_script.collapseuser()).replace('~', '$HOME')}"
+            source_copy = f". {str(init_script_copy).replace('~', '$HOME')}"
+        else:
+            init_script = PathExtended(LIBRARY_ROOT).joinpath("settings/shells/bash/init.sh")
+            init_script_copy = PathExtended(CONFIG_PATH).joinpath("profile/init.sh").collapseuser()
+            source_reference = f"source {str(init_script.collapseuser()).replace('~', '$HOME')}"
+            source_copy = f"source {str(init_script_copy).replace('~', '$HOME')}"
+
+        configured = source_reference in profile_content or source_copy in profile_content
+        method = "reference" if source_reference in profile_content else ("copy" if source_copy in profile_content else "none")
+
+        return {
+            "profile_path": str(profile_path),
+            "exists": profile_exists,
+            "configured": configured,
+            "method": method,
+            "init_script_exists": init_script.exists(),
+            "init_script_copy_exists": init_script_copy.exists(),
+        }
+    except Exception as ex:
+        return {"profile_path": "Error", "exists": False, "configured": False, "method": "error", "error": str(ex), "init_script_exists": False, "init_script_copy_exists": False}
+
+
+def _check_machineconfig_repo() -> dict[str, Any]:
+    """Check machineconfig repository status."""
+    repo_path = Path.home().joinpath("code/machineconfig")
+    if not repo_path.exists():
+        return {"exists": False, "is_repo": False, "clean": False, "branch": "N/A", "commit": "N/A", "remotes": []}
+
+    try:
+        import git
+
+        repo = git.Repo(str(repo_path))
+        is_dirty = repo.is_dirty(untracked_files=True)
+        current_branch = repo.active_branch.name if not repo.head.is_detached else "DETACHED"
+        current_commit = repo.head.commit.hexsha[:8]
+        remotes = [remote.name for remote in repo.remotes]
+
+        return {
+            "exists": True,
+            "is_repo": True,
+            "clean": not is_dirty,
+            "branch": current_branch,
+            "commit": current_commit,
+            "remotes": remotes,
+            "path": str(repo_path),
+        }
+    except Exception as ex:
+        return {"exists": True, "is_repo": False, "clean": False, "branch": "Error", "commit": "N/A", "remotes": [], "error": str(ex)}
+
+
+def _check_repos_status() -> dict[str, Any]:
+    """Check configured repositories status."""
+    from machineconfig.utils.io import read_ini
+
+    try:
+        repos_str = read_ini(DEFAULTS_PATH)["general"]["repos"]
+        repo_paths = [Path(p.strip()).expanduser() for p in repos_str.split(",") if p.strip()]
+
+        repos_info = []
+        for repo_path in repo_paths:
+            if not repo_path.exists():
+                repos_info.append({"path": str(repo_path), "name": repo_path.name, "exists": False, "is_repo": False})
+                continue
+
+            try:
+                import git
+
+                repo = git.Repo(str(repo_path))
+                repos_info.append({"path": str(repo_path), "name": repo_path.name, "exists": True, "is_repo": True, "clean": not repo.is_dirty(untracked_files=True), "branch": repo.active_branch.name if not repo.head.is_detached else "DETACHED"})
+            except Exception:
+                repos_info.append({"path": str(repo_path), "name": repo_path.name, "exists": True, "is_repo": False})
+
+        return {"configured": True, "count": len(repos_info), "repos": repos_info}
+    except (FileNotFoundError, KeyError, IndexError):
+        return {"configured": False, "count": 0, "repos": []}
+
+
+def _check_ssh_status() -> dict[str, Any]:
+    """Check SSH configuration status."""
+    ssh_dir = PathExtended.home().joinpath(".ssh")
+    if not ssh_dir.exists():
+        return {"ssh_dir_exists": False, "keys": [], "config_exists": False, "authorized_keys_exists": False, "known_hosts_exists": False}
+
+    keys = []
+    for pub_key in ssh_dir.glob("*.pub"):
+        private_key = pub_key.with_suffix("")
+        keys.append({"name": pub_key.stem, "public_exists": True, "private_exists": private_key.exists(), "public_path": str(pub_key), "private_path": str(private_key)})
+
+    config_file = ssh_dir.joinpath("config")
+    authorized_keys = ssh_dir.joinpath("authorized_keys")
+    known_hosts = ssh_dir.joinpath("known_hosts")
+
+    return {
+        "ssh_dir_exists": True,
+        "keys": keys,
+        "config_exists": config_file.exists(),
+        "authorized_keys_exists": authorized_keys.exists(),
+        "known_hosts_exists": known_hosts.exists(),
+        "ssh_dir_path": str(ssh_dir),
+    }
+
+
+def _check_config_files_status() -> dict[str, Any]:
+    """Check public and private configuration files status."""
+    from machineconfig.profile.create import read_mapper
+
+    try:
+        mapper = read_mapper()
+        public_configs = list(mapper.get("public", {}).keys())
+        private_configs = list(mapper.get("private", {}).keys())
+
+        public_count = len(public_configs)
+        private_count = len(private_configs)
+
+        public_linked = 0
+        for config_name in public_configs:
+            for config_item in mapper["public"][config_name]:
+                target_path = PathExtended(config_item["config_file_default_path"]).expanduser()
+                if target_path.exists():
+                    public_linked += 1
+                    break
+
+        private_linked = 0
+        for config_name in private_configs:
+            for config_item in mapper["private"][config_name]:
+                target_path = PathExtended(config_item["config_file_default_path"]).expanduser()
+                if target_path.exists():
+                    private_linked += 1
+                    break
+
+        return {
+            "public_count": public_count,
+            "public_linked": public_linked,
+            "private_count": private_count,
+            "private_linked": private_linked,
+            "public_configs": public_configs,
+            "private_configs": private_configs,
+        }
+    except Exception as ex:
+        return {"public_count": 0, "public_linked": 0, "private_count": 0, "private_linked": 0, "error": str(ex), "public_configs": [], "private_configs": []}
+
+
+def _check_important_tools() -> dict[str, dict[str, bool]]:
+    """Check if important CLI tools are installed, organized by groups."""
+    from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+    
+    group_status = {}
+    for group_name, tools in PACKAGE_GROUP2NAMES.items():
+        tool_status = {}
+        for tool in tools:
+            tool_status[tool] = shutil.which(tool) is not None
+        group_status[group_name] = tool_status
+
+    return group_status
+
+
+def _check_backup_config() -> dict[str, Any]:
+    """Check backup configuration status."""
+    from machineconfig.utils.io import read_ini
+    import tomllib
+
+    try:
+        cloud_config = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
+    except (FileNotFoundError, KeyError, IndexError):
+        cloud_config = "Not configured"
+
+    try:
+        backup_file = LIBRARY_ROOT.joinpath("profile/backup.toml")
+        if backup_file.exists():
+            backup_data = tomllib.loads(backup_file.read_text(encoding="utf-8"))
+            backup_items = list(backup_data.keys())
+            backup_items_count = len(backup_items)
+        else:
+            backup_items = []
+            backup_items_count = 0
+    except Exception:
+        backup_items = []
+        backup_items_count = 0
+
+    return {"cloud_config": cloud_config, "backup_items_count": backup_items_count, "backup_items": backup_items}
+
+
+def _display_system_info(info: dict[str, str]) -> None:
+    """Display system information panel."""
+    console.rule("[bold blue]💻 System Information[/bold blue]")
+
+    table = Table(show_header=False, box=None, padding=(0, 1), expand=False)
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+
+    table.add_row("🏠 Hostname", info["hostname"])
+    table.add_row("💿 System", f"{info['system']} {info['release']}")
+    table.add_row("🖥️  Machine", info["machine"])
+    table.add_row("⚙️  Processor", info["processor"])
+    table.add_row("🐍 Python", info["python_version"])
+    table.add_row("👤 User", info["user"])
+
+    console.print(Panel(table, title="System", border_style="blue", padding=(1, 2), expand=False))
+
+
+def _display_shell_status(status: dict[str, Any]) -> None:
+    """Display shell profile status panel."""
+    console.rule("[bold green]🐚 Shell Profile[/bold green]")
+
+    if "error" in status:
+        console.print(Panel(f"❌ Error: {status['error']}", title="Shell Profile", border_style="red", padding=(1, 2), expand=False))
+        return
+
+    from rich.columns import Columns
+    
+    left_table = Table(show_header=False, box=None, padding=(0, 1))
+    left_table.add_column("Item", style="cyan", no_wrap=True)
+    left_table.add_column("Status")
+    
+    left_table.add_row("📄 Profile", status['profile_path'])
+    left_table.add_row(f"{'✅' if status['exists'] else '❌'} Exists", str(status['exists']))
+    left_table.add_row(f"{'✅' if status['configured'] else '❌'} Configured", str(status['configured']))
+    
+    right_table = Table(show_header=False, box=None, padding=(0, 1))
+    right_table.add_column("Item", style="cyan", no_wrap=True)
+    right_table.add_column("Status")
+    
+    right_table.add_row("🔧 Method", status['method'])
+    right_table.add_row(f"{'✅' if status['init_script_exists'] else '❌'} Init (source)", str(status['init_script_exists']))
+    right_table.add_row(f"{'✅' if status['init_script_copy_exists'] else '❌'} Init (copy)", str(status['init_script_copy_exists']))
+
+    border_style = "green" if status["configured"] else "yellow"
+    console.print(Panel(Columns([left_table, right_table], equal=True, expand=True), title="Shell Profile", border_style=border_style, padding=(1, 2), expand=False))
+
+
+def _display_machineconfig_repo(info: dict[str, Any]) -> None:
+    """Display machineconfig repository status."""
+    console.rule("[bold magenta]📦 Machineconfig Repository[/bold magenta]")
+
+    if not info["exists"]:
+        console.print(Panel("❌ Machineconfig repository not found at ~/code/machineconfig", title="Repository Status", border_style="red", padding=(1, 2), expand=False))
+        return
+
+    if not info["is_repo"]:
+        console.print(Panel(f"❌ Directory exists but is not a git repository\n{info.get('error', 'Unknown error')}", title="Repository Status", border_style="red", padding=(1, 2), expand=False))
+        return
+
+    table = Table(show_header=False, box=None, padding=(0, 1), expand=False)
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    
+    table.add_row("📁 Path", info['path'])
+    table.add_row("🌿 Branch", info['branch'])
+    table.add_row("🔖 Commit", info['commit'])
+    table.add_row(f"{'✅' if info['clean'] else '⚠️'} Status", 'Clean' if info['clean'] else 'Uncommitted changes')
+    table.add_row("📡 Remotes", ', '.join(info['remotes']) if info['remotes'] else 'None')
+
+    border_style = "green" if info["clean"] else "yellow"
+    console.print(Panel(table, title="Machineconfig Repository", border_style=border_style, padding=(1, 2), expand=False))
+
+
+def _display_repos_status(status: dict[str, Any]) -> None:
+    """Display configured repositories status."""
+    console.rule("[bold cyan]📚 Configured Repositories[/bold cyan]")
+
+    if not status["configured"]:
+        console.print(Panel(f"⚠️  No repositories configured in {DEFAULTS_PATH}", title="Repositories", border_style="yellow", padding=(1, 2)))
+        return
+
+    if status["count"] == 0:
+        console.print(Panel("ℹ️  No repositories configured", title="Repositories", border_style="blue", padding=(1, 2)))
+        return
+
+    table = Table(show_lines=True, header_style="bold cyan")
+    table.add_column("Repository", style="bold")
+    table.add_column("Status")
+    table.add_column("Details")
+
+    for repo in status["repos"]:
+        name = repo["name"]
+        if not repo["exists"]:
+            table.add_row(f"❌ {name}", "Missing", f"Path: {repo['path']}")
+        elif not repo["is_repo"]:
+            table.add_row(f"⚠️  {name}", "Not a repo", f"Path: {repo['path']}")
+        else:
+            status_icon = "✅" if repo["clean"] else "⚠️"
+            status_text = "Clean" if repo["clean"] else "Uncommitted changes"
+            table.add_row(f"{status_icon} {name}", status_text, f"Branch: {repo['branch']}")
+
+    console.print(Panel(table, title=f"Repositories ({status['count']})", border_style="cyan", padding=(1, 2)))
+
+
+def _display_ssh_status(status: dict[str, Any]) -> None:
+    """Display SSH configuration status."""
+    console.rule("[bold yellow]🔐 SSH Configuration[/bold yellow]")
+
+    if not status["ssh_dir_exists"]:
+        console.print(Panel("❌ SSH directory (~/.ssh) does not exist", title="SSH Status", border_style="red", padding=(1, 2), expand=False))
+        return
+
+    from rich.columns import Columns
+    
+    config_table = Table(show_header=False, box=None, padding=(0, 1))
+    config_table.add_column("Item", style="cyan", no_wrap=True)
+    config_table.add_column("Status")
+    
+    config_table.add_row("📁 Directory", status['ssh_dir_path'])
+    config_table.add_row(f"{'✅' if status['config_exists'] else '❌'} Config", str(status['config_exists']))
+    config_table.add_row(f"{'✅' if status['authorized_keys_exists'] else '❌'} Auth Keys", str(status['authorized_keys_exists']))
+    config_table.add_row(f"{'✅' if status['known_hosts_exists'] else '❌'} Known Hosts", str(status['known_hosts_exists']))
+
+    config_panel = Panel(config_table, title="SSH Config", border_style="yellow", padding=(1, 2), expand=False)
+
+    if status["keys"]:
+        keys_table = Table(show_header=True, box=None, padding=(0, 1), show_lines=False, expand=False)
+        keys_table.add_column("Key Name", style="bold cyan")
+        keys_table.add_column("Pub", justify="center")
+        keys_table.add_column("Priv", justify="center")
+
+        for key in status["keys"]:
+            pub_status = "✅" if key["public_exists"] else "❌"
+            priv_status = "✅" if key["private_exists"] else "❌"
+            keys_table.add_row(key["name"], pub_status, priv_status)
+
+        keys_panel = Panel(keys_table, title=f"SSH Keys ({len(status['keys'])})", border_style="yellow", padding=(1, 2), expand=False)
+        
+        console.print(Columns([config_panel, keys_panel], equal=False, expand=True))
+    else:
+        console.print(config_panel)
+
+
+def _display_config_files_status(status: dict[str, Any]) -> None:
+    """Display configuration files status."""
+    console.rule("[bold bright_blue]⚙️  Configuration Files[/bold bright_blue]")
+
+    if "error" in status:
+        console.print(Panel(f"❌ Error reading configuration: {status['error']}", title="Configuration Files", border_style="red", padding=(1, 2), expand=False))
+        return
+
+    public_percentage = (status["public_linked"] / status["public_count"] * 100) if status["public_count"] > 0 else 0
+    private_percentage = (status["private_linked"] / status["private_count"] * 100) if status["private_count"] > 0 else 0
+
+    table = Table(show_header=True, box=None, padding=(0, 2), expand=False)
+    table.add_column("Type", style="cyan", no_wrap=True)
+    table.add_column("Linked", justify="right")
+    table.add_column("Total", justify="right")
+    table.add_column("Progress", justify="right")
+    
+    table.add_row("📂 Public", str(status['public_linked']), str(status['public_count']), f"{public_percentage:.0f}%")
+    table.add_row("🔒 Private", str(status['private_linked']), str(status['private_count']), f"{private_percentage:.0f}%")
+
+    overall_linked = status["public_linked"] + status["private_linked"]
+    overall_total = status["public_count"] + status["private_count"]
+    overall_percentage = (overall_linked / overall_total * 100) if overall_total > 0 else 0
+
+    border_style = "green" if overall_percentage > 80 else ("yellow" if overall_percentage > 50 else "red")
+
+    console.print(Panel(table, title=f"Configuration Files ({overall_percentage:.0f}% configured)", border_style=border_style, padding=(1, 2), expand=False))
+
+
+def _display_tools_status(grouped_tools: dict[str, dict[str, bool]]) -> None:
+    """Display important tools installation status organized by groups."""
+    console.rule("[bold bright_magenta]🛠️  Important Tools[/bold bright_magenta]")
+
+    from rich.columns import Columns
+    
+    all_group_panels = []
+    total_installed = 0
+    total_tools = 0
+    
+    for group_name, tools in grouped_tools.items():
+        sorted_tools = sorted(tools.keys())
+        installed = [tool for tool, status in tools.items() if status]
+        total_installed += len(installed)
+        total_tools += len(tools)
+        
+        num_columns = 8
+        tools_per_column = (len(sorted_tools) + num_columns - 1) // num_columns
+        
+        tables = []
+        for col_idx in range(num_columns):
+            table = Table(show_header=False, box=None, padding=(0, 0), collapse_padding=True)
+            table.add_column("Tool", style="cyan", no_wrap=True, width=None)
+            table.add_column("", justify="center", width=2, no_wrap=True)
+            
+            start_idx = col_idx * tools_per_column
+            end_idx = min(start_idx + tools_per_column, len(sorted_tools))
+            
+            for i in range(start_idx, end_idx):
+                tool = sorted_tools[i]
+                status_icon = "✅" if tools[tool] else "❌"
+                table.add_row(tool, status_icon)
+            
+            if start_idx < len(sorted_tools):
+                tables.append(table)
+
+        installed_percentage = (len(installed) / len(tools) * 100) if tools else 0
+        border_style = "green" if installed_percentage > 80 else ("yellow" if installed_percentage > 50 else "red")
+        
+        group_display_name = group_name.replace("_", " ").title()
+        group_panel = Panel(
+            Columns(tables, equal=False, expand=False, padding=(0, 1)),
+            title=f"{group_display_name} ({len(installed)}/{len(tools)})",
+            border_style=border_style,
+            padding=(0, 1),
+            expand=False
+        )
+        all_group_panels.append(group_panel)
+    
+    overall_percentage = (total_installed / total_tools * 100) if total_tools else 0
+    master_border_style = "green" if overall_percentage > 80 else ("yellow" if overall_percentage > 50 else "red")
+    
+    from rich.console import Group
+    master_panel = Panel(
+        Group(*all_group_panels),
+        title=f"🛠️  Tools Overview ({total_installed}/{total_tools} installed - {overall_percentage:.0f}%)",
+        border_style=master_border_style,
+        padding=(1, 2),
+        expand=False
+    )
+    console.print(master_panel)
+
+
+def _display_backup_status(status: dict[str, Any]) -> None:
+    """Display backup configuration status."""
+    console.rule("[bold bright_cyan]💾 Backup Configuration[/bold bright_cyan]")
+
+    table = Table(show_header=False, box=None, padding=(0, 1), expand=False)
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    
+    table.add_row("🌥️  Cloud Config", status['cloud_config'])
+    table.add_row("📦 Backup Items", str(status['backup_items_count']))
+
+    border_style = "green" if status["cloud_config"] != "Not configured" else "yellow"
+
+    console.print(Panel(table, title="Backup Configuration", border_style=border_style, padding=(1, 2), expand=False))
+
+
+def main() -> None:
+    """Main function to display comprehensive machine status."""
+    console.print("\n")
+    console.print(Panel(Text("📊 Machine Status Report", justify="center", style="bold white"), style="bold blue", padding=(1, 2)))
+    console.print("\n")
+
+    system_info = _check_system_info()
+    _display_system_info(system_info)
+
+    shell_status = _check_shell_profile_status()
+    _display_shell_status(shell_status)
+
+    machineconfig_repo = _check_machineconfig_repo()
+    _display_machineconfig_repo(machineconfig_repo)
+
+    repos_status = _check_repos_status()
+    _display_repos_status(repos_status)
+
+    ssh_status = _check_ssh_status()
+    _display_ssh_status(ssh_status)
+
+    config_status = _check_config_files_status()
+    _display_config_files_status(config_status)
+
+    tools_status = _check_important_tools()
+    _display_tools_status(tools_status)
+
+    backup_status = _check_backup_config()
+    _display_backup_status(backup_status)
+
+    console.print("\n")
+    console.print(Panel(Text("✨ Status report complete!", justify="center", style="bold green"), style="green", padding=(1, 2)))
+    console.print("\n")
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/devops_update_repos.py

@@ -148,7 +148,7 @@ def _display_summary(results: list[RepositoryUpdateResult]) -> None:
 def main(verbose: bool = True, allow_password_prompt: bool = False) -> None:
     """Main function to update all configured repositories."""
     _ = verbose
-    repos: list[Path] = [Path.home() / "code/machineconfig", Path.home() / "code/crocodile"]
+    repos: list[Path] = [Path.home() / "code/machineconfig"]
     try:
         tmp = read_ini(DEFAULTS_PATH)["general"]["repos"].split(",")
         if tmp[-1] == "":

machineconfig/scripts/python/fire_agents_help_launch.py

@@ -42,6 +42,9 @@ def prep_agent_launch(agents_dir: Path, prompts_material: list[str], prompt_pref
         cmd_prefix = f"""
 #!/usr/bin/env bash
 
+sleep 5
+timeout 3 copilot --banner
+
 # AGENT-{idx}-LAUNCH-SCRIPT
 # Auto-generated by fire_agents.py
 
@@ -74,15 +77,17 @@ sleep 0.1
                 api_key = api_keys[idx % len(api_keys)] if api_keys else ""
                 # Export the environment variable so it's available to subshells
                 cmd = f"""
+
 export GEMINI_API_KEY={shlex.quote(api_key)}
 echo "Using Gemini API key $GEMINI_API_KEY"
+
 gemini {model_arg} --yolo --prompt {safe_path}
 """
             case "cursor-agent":
                 # As originally implemented
                 cmd = f"""
 
-cursor-agent --print --output-format text < {prompt_path}
+cursor-agent --print --output-format text {prompt_path}
 
 """
             case "crush":

machineconfig/scripts/python/fire_jobs_args_helper.py

@@ -24,7 +24,6 @@ class FireJobArgs:
     PathExport: bool = False
     git_pull: bool = False
     optimized: bool = False
-    Nprocess: int = 1
     zellij_tab: Optional[str] = None
     watch: bool = False
 
@@ -96,6 +95,10 @@ def _convert_value_type(value: str) -> object:
     elif value.lower() in ('false', '0', 'no', 'off'):
         return False
     
+    # Try to convert None
+    if value.lower() == 'none':
+        return None
+    
     # Try to parse as list (comma-separated values)
     if ',' in value:
         items = [_convert_value_type(item.strip()) for item in value.split(',')]

machineconfig/scripts/python/helpers/repo_sync_helpers.py

@@ -1,11 +1,7 @@
 from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.terminal import Response
 from machineconfig.scripts.python.get_zellij_cmd import get_zellij_cmd
-from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
-from machineconfig.utils.io import read_ini
 from machineconfig.utils.code import write_shell_script_to_file
 import platform
-import subprocess
 from rich.console import Console
 from rich.panel import Panel
 
@@ -33,9 +29,6 @@ def delete_remote_repo_copy_and_push_local(remote_repo: str, local_repo: str, cl
     console.print(Panel("✅ Repository successfully pushed to cloud", title="[bold green]Repo Sync[/bold green]", border_style="green"))
 
 
-# import sys
-# import subprocess
-
 
 def get_wt_cmd(wd1: PathExtended, wd2: PathExtended) -> str:
     lines = [
@@ -60,42 +53,6 @@ def inspect_repos(repo_local_root: str, repo_remote_root: str):
         raise NotImplementedError(f"Platform {platform.system()} not implemented.")
 
 
-def fetch_dotfiles():
-    console.print(Panel("📁 Fetching Dotfiles", title="[bold blue]Dotfiles[/bold blue]", border_style="blue"))
-
-    cloud_resolved = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
-    console.print(Panel(f"⚠️  Using default cloud: `{cloud_resolved}` from {DEFAULTS_PATH}", width=150, border_style="yellow"))
-
-    dotfiles_local = PathExtended.home().joinpath("dotfiles")
-    CONFIG_PATH.joinpath("remote").mkdir(parents=True, exist_ok=True)
-    dotfiles_remote = PathExtended(CONFIG_PATH).joinpath("remote", dotfiles_local.rel2home())
-    remote_path = dotfiles_local.get_remote_path(rel2home=True, os_specific=False, root="myhome") + ".zip.enc"
-
-    console.print(Panel("📥 Downloading dotfiles from cloud...", width=150, border_style="blue"))
-
-    dotfiles_remote.from_cloud(remotepath=remote_path, cloud=cloud_resolved, unzip=True, decrypt=True, rel2home=True, os_specific=False, pwd=None)
-
-    console.print(Panel("🗑️  Removing old dotfiles and replacing with cloud version...", width=150, border_style="blue"))
-
-    dotfiles_local.delete(sure=True)
-    dotfiles_remote.move(folder=PathExtended.home())
-    script = f"""
-# rm -rf {dotfiles_local}
-# mv {dotfiles_remote} {dotfiles_local}
-"""
-    if platform.system() == "Linux":
-        script += """
-sudo chmod 600 $HOME/.ssh/*
-sudo chmod 700 $HOME/.ssh
-sudo chmod +x $HOME/dotfiles/scripts/linux -R
-"""
-    shell_path = write_shell_script_to_file(shell_script=script)
-    completed = subprocess.run(f". {shell_path}", capture_output=True, check=False, text=True, shell=True)
-    Response.from_completed_process(completed).capture().print()
-
-    console.print(Panel("✅ Dotfiles successfully fetched and installed", title="[bold green]Dotfiles[/bold green]", border_style="green"))
-
-
 def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool) -> bool:
     dotfiles_path = str(PathExtended.home().joinpath("dotfiles"))
     from git import Repo

machineconfig/scripts/python/onetimeshare.py

@@ -6,7 +6,6 @@
 # # or use ots executable to do this job
 
 # import requests
-# import crocodile.file_management as fm
 # import base64
 # from typing import Optional
 

machineconfig/scripts/windows/share_smb.ps1

@@ -4,12 +4,6 @@ $Path = $HOME + '\data\share_smb'
 
 Get-SmbShare
 
-
-#. activate_ve
-#python -m machineconfig.scripts.python.share_smb
-#. $HOME/tmp_results/shells/python_return_command.ps1
-
-# make $path dir if it does not exist
 if (!(Test-Path -Path $Path)) {
     New-Item -ItemType Directory -Path $Path
 }