machineconfig 5.15__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/profile/create_helper.py

@@ -0,0 +1,62 @@
+
+from typing import Literal
+from pathlib import Path
+import shutil
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, CONFIG_ROOT
+
+
+def _copy_path(source: Path, target: Path, overwrite: bool = False) -> None:
+    source = source.expanduser().resolve()
+    target = target.expanduser().resolve()
+    if not source.exists():
+        raise FileNotFoundError(f"Source path does not exist: {source}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    if target.exists() and not overwrite:
+        raise FileExistsError(f"Target already exists and overwrite=False: {target}")
+    if target.exists() and overwrite:
+        if target.is_dir():
+            shutil.rmtree(target)
+        else:
+            target.unlink()
+    if source.is_file():
+        shutil.copy2(source, target)
+    elif source.is_dir():
+        shutil.copytree(source, target, dirs_exist_ok=overwrite)
+    else:
+        raise ValueError(f"Source is neither file nor directory: {source}")
+
+
+def copy_assets_to_machine(which: Literal["scripts", "settings"]) -> None:
+    import platform
+    import subprocess
+    
+    system_name = platform.system().lower()
+    if system_name == "windows":
+        system = "windows"
+    elif system_name in {"linux", "darwin"}:
+        system = "linux"
+    else:
+        raise NotImplementedError(f"System {system_name} not supported")
+
+    match which:
+        case "scripts":
+            source = LIBRARY_ROOT.joinpath("scripts", system)
+            target = CONFIG_ROOT.joinpath("scripts")
+            
+            wrap_mcfg_source = LIBRARY_ROOT.joinpath("scripts", "nu", "wrap_mcfg.nu")
+            wrap_mcfg_target = CONFIG_ROOT.joinpath("scripts", "wrap_mcfg.nu")
+            wrap_mcfg_target.parent.mkdir(parents=True, exist_ok=True)
+            _copy_path(source=wrap_mcfg_source, target=wrap_mcfg_target, overwrite=True)
+        case "settings":
+            source = LIBRARY_ROOT.joinpath("settings")
+            target = CONFIG_ROOT.joinpath("settings")
+
+    _copy_path(source=source, target=target, overwrite=True)
+    
+    if system_name == "linux" and which == "scripts":
+        from rich.console import Console
+        console = Console()
+        console.print("\n[bold]📜 Setting executable permissions for scripts...[/bold]")
+        scripts_path = CONFIG_ROOT.joinpath("scripts")
+        subprocess.run(f"chmod +x {scripts_path} -R", shell=True, capture_output=True, text=True, check=False)
+        console.print("[green]✅ Script permissions updated[/green]")

machineconfig/profile/create_links.py

@@ -0,0 +1,288 @@
+"""
+This script Takes away all config files from the computer, place them in one directory
+`dotfiles`, and create symlinks to those files from thier original locations.
+
+"""
+
+from machineconfig.utils.links import OperationRecord
+from rich.console import Console
+from rich.panel import Panel
+from rich.pretty import Pretty
+from rich.text import Text
+from rich.table import Table
+
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.links import symlink_map, copy_map
+from machineconfig.profile.create_links_export import ON_CONFLICT_STRICT
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT, CONFIG_ROOT
+
+import platform
+import subprocess
+import tomllib
+from typing import Optional, Any, TypedDict, Literal
+
+
+system = platform.system()  # Linux or Windows
+ERROR_LIST: list[Any] = []  # append to this after every exception captured.
+SYSTEM = system.lower()
+
+console = Console()
+
+
+class Base(TypedDict):
+    this: str
+    to_this: str
+    contents: Optional[bool]
+    copy: Optional[bool]
+class ConfigMapper(TypedDict):
+    file_name: str
+    config_file_default_path: str
+    self_managed_config_file_path: str
+    contents: Optional[bool]
+    copy: Optional[bool]
+class MapperFileData(TypedDict):
+    public: dict[str, list[ConfigMapper]]
+    private: dict[str, list[ConfigMapper]]
+def read_mapper() -> MapperFileData:
+    mapper_data: dict[str, dict[str, Base]] = tomllib.loads(LIBRARY_ROOT.joinpath("profile/mapper.toml").read_text(encoding="utf-8"))
+    public: dict[str, list[ConfigMapper]] = {}
+    private: dict[str, list[ConfigMapper]] = {}
+    # def get_other_systems(current_system: str) -> list[str]:
+    #     all_systems = ["linux", "windows", "darwin"]
+    #     return [s for s in all_systems if s != current_system.lower()]
+    # OTHER_SYSTEMS = get_other_systems(SYSTEM)
+    for program_key, program_map in mapper_data.items():
+        parts = program_key.split("_")
+        if len(parts) > 1:
+            if parts[-1].lower() == "windows" and SYSTEM != "windows":
+                # console.print(f"Skipping Windows-only program mapping: {program_key}")
+                continue
+            elif parts[-1].lower() == "linux" and SYSTEM == "windows":
+                # console.print(f"Skipping Linux-only program mapping: {program_key}")
+                continue
+        for file_name, file_base in program_map.items():
+            file_map: ConfigMapper = {
+                "file_name": file_name,
+                "config_file_default_path": file_base["this"],
+                "self_managed_config_file_path": file_base["to_this"],
+                "contents": file_base.get("contents"),
+                "copy": file_base.get("copy"),
+            }
+            if "CONFIG_ROOT" in file_map["self_managed_config_file_path"]:
+                if program_key not in public:
+                    public[program_key] = []
+                public[program_key].append(file_map)
+            else:
+                if program_key not in private:
+                    private[program_key] = []
+                private[program_key].append(file_map)
+    return {"public": public, "private": private}
+
+
+def apply_mapper(mapper_data: dict[str, list[ConfigMapper]],
+                 on_conflict: ON_CONFLICT_STRICT,
+                 method: Literal["symlink", "copy"]
+                 ):
+    operation_records: list[OperationRecord] = []
+    print(f"Working with {len(mapper_data)} programs from mapper data.")
+    if len(mapper_data) == 1:
+        print(mapper_data)
+    import os
+    if os.name == "nt":
+        import ctypes
+        try:
+            is_admin = ctypes.windll.shell32.IsUserAnAdmin()
+        except Exception:
+            is_admin = False
+        total_length = sum(len(item) for item in mapper_data.values())
+        if not is_admin and method == "symlink" and total_length > 5:
+            warning_body = "\n".join([
+                "[bold yellow]Administrator privileges required[/]",
+                "Run the terminal as admin and try again to avoid repeated elevation prompts.",
+            ])
+            console.print(
+                Panel.fit(
+                    warning_body,
+                    title="⚠️ Permission Needed",
+                    border_style="yellow",
+                    padding=(1, 2),
+                )
+            )
+            raise RuntimeError("Run terminal as admin and try again, otherwise, there will be too many popups for admin requests and no chance to terminate the program.")
+    for program_name, program_files in mapper_data.items():
+        console.rule(f"🔄 Processing [bold]{program_name}[/] symlinks", style="cyan")
+        for a_mapper in program_files:
+            config_file_default_path = PathExtended(a_mapper["config_file_default_path"])
+            self_managed_config_file_path = PathExtended(a_mapper["self_managed_config_file_path"].replace("CONFIG_ROOT", CONFIG_ROOT.as_posix()))
+            # Determine whether to use copy or symlink
+            use_copy = method == "copy" or a_mapper.get("copy", False)
+            if "contents" in a_mapper and a_mapper["contents"]:
+                targets = list(self_managed_config_file_path.expanduser().search("*"))
+                for a_target in targets:
+                    operation_type = "contents_copy" if use_copy else "contents_symlink"
+                    try:
+                        if use_copy:
+                            result = copy_map(config_file_default_path=config_file_default_path.joinpath(a_target.name), self_managed_config_file_path=a_target, on_conflict=on_conflict)
+                        else:
+                            result = symlink_map(config_file_default_path=config_file_default_path.joinpath(a_target.name), self_managed_config_file_path=a_target, on_conflict=on_conflict)
+                        operation_records.append({
+                            "program": program_name,
+                            "file_key": a_mapper["file_name"],
+                            "defaultPath": str(config_file_default_path.joinpath(a_target.name)),
+                            "selfManaged": str(a_target),
+                            "operation": operation_type,
+                            "action": result["action"],
+                            "details": result["details"],
+                            "status": "success"
+                        })
+                    except ValueError as ex:
+                        if "resolve to the same location" in str(ex):
+                            operation_records.append({
+                                "program": program_name,
+                                "file_key": a_mapper["file_name"],
+                                "defaultPath": str(config_file_default_path.joinpath(a_target.name)),
+                                "selfManaged": str(a_target),
+                                "operation": operation_type,
+                                "action": "already_linked",
+                                "details": "defaultPath and selfManaged resolve to same location - already correctly configured",
+                                "status": "success"
+                            })
+                        else:
+                            raise
+                    except Exception as ex:
+                        console.print(f"❌ [red]Config error[/red]: {program_name} | {a_mapper['file_name']} | {a_target.name}. {ex}")
+                        operation_records.append({
+                            "program": program_name,
+                            "file_key": a_mapper["file_name"],
+                            "defaultPath": str(config_file_default_path.joinpath(a_target.name)),
+                            "selfManaged": str(a_target),
+                            "operation": operation_type,
+                            "action": "error",
+                            "details": f"Failed to process contents: {str(ex)}",
+                            "status": f"error: {str(ex)}"
+                        })                    
+            else:
+                operation_type = "copy" if use_copy else "symlink"
+                try:
+                    if use_copy:
+                        result = copy_map(config_file_default_path=config_file_default_path, self_managed_config_file_path=self_managed_config_file_path, on_conflict=on_conflict)
+                    else:
+                        result = symlink_map(config_file_default_path=config_file_default_path, self_managed_config_file_path=self_managed_config_file_path, on_conflict=on_conflict)
+                    operation_records.append({
+                        "program": program_name,
+                        "file_key": a_mapper["file_name"],
+                        "defaultPath": str(config_file_default_path),
+                        "selfManaged": str(self_managed_config_file_path),
+                        "operation": operation_type,
+                        "action": result["action"],
+                        "details": result["details"],
+                        "status": "success"
+                    })
+                except ValueError as ex:
+                    if "resolve to the same location" in str(ex):
+                        operation_records.append({
+                            "program": program_name,
+                            "file_key": a_mapper["file_name"],
+                            "defaultPath": str(config_file_default_path),
+                            "selfManaged": str(self_managed_config_file_path),
+                            "operation": operation_type,
+                            "action": "already_linked",
+                            "details": "defaultPath and selfManaged resolve to same location - already correctly configured",
+                            "status": "success"
+                        })
+                    else:
+                        raise
+                except Exception as ex:
+                    console.print(f"❌ [red]Config error[/red]: {program_name} | {a_mapper['file_name']} | {ex}")
+                    operation_records.append({
+                        "program": program_name,
+                        "file_key": a_mapper["file_name"],
+                        "defaultPath": str(config_file_default_path),
+                        "selfManaged": str(self_managed_config_file_path),
+                        "operation": operation_type,
+                        "action": "error",
+                        "details": f"Failed to create {operation_type}: {str(ex)}",
+                        "status": f"error: {str(ex)}"
+                    })
+
+            if program_name == "ssh" and system == "Linux":  # permissions of ~/dotfiles/.ssh should be adjusted
+                try:
+                    console.print("\n[bold]🔒 Setting secure permissions for SSH files...[/bold]")
+                    subprocess.run("chmod 700 $HOME/.ssh/", shell=True, check=True)
+                    subprocess.run("chmod 700 $HOME/dotfiles/creds/.ssh/", shell=True, check=True)
+                    subprocess.run("chmod 600 $HOME/dotfiles/creds/.ssh/*", shell=True, check=True)
+                    subprocess.run("chmod 600 $HOME/.ssh/*", shell=True, check=True)
+                    console.print("[green]✅ SSH permissions set successfully[/green]")
+                except Exception as e:
+                    ERROR_LIST.append(e)
+                    console.print(f"❌ [red]Error setting SSH permissions[/red]: {e}")
+
+    # Display operation summary table
+    if operation_records:
+        table = Table(title="🔗 Symlink Operations Summary", show_header=True, header_style="bold magenta")
+        table.add_column("Program", style="cyan", no_wrap=True)
+        table.add_column("File Key", style="blue", no_wrap=True)
+        table.add_column("Default Path", style="green")
+        table.add_column("Self Managed", style="yellow")
+        table.add_column("Operation", style="magenta", no_wrap=True)
+        table.add_column("Action", style="red", no_wrap=True)
+        table.add_column("Details", style="white")
+        table.add_column("Status", style="red", no_wrap=True)
+        
+        for record in operation_records:
+            status_style = "green" if record["status"] == "success" else "red"
+            action_style = "green" if record["action"] != "error" else "red"
+            table.add_row(
+                record["program"],
+                record["file_key"],
+                record["defaultPath"],
+                record["selfManaged"],
+                record["operation"],
+                f"[{action_style}]{record['action']}[/{action_style}]",
+                record["details"],
+                f"[{status_style}]{record['status']}[/{status_style}]"
+            )
+        
+        console.print("\n")
+        console.print(table)
+        
+        # Export operation records to CSV
+        import csv
+        from datetime import datetime
+
+        csv_dir = PathExtended(CONFIG_ROOT).joinpath("symlink_operations")
+        csv_dir.mkdir(parents=True, exist_ok=True)
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        csv_filename = f"symlink_operations_{timestamp}.csv"
+        csv_path = csv_dir.joinpath(csv_filename)
+        
+        with open(csv_path, "w", newline="", encoding="utf-8") as csvfile:
+            fieldnames = ["program", "file_key", "defaultPath", "selfManaged", "operation", "action", "details", "status"]
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(operation_records)
+        
+        console.print(f"\n[bold green]📊 Operations exported to CSV:[/bold green] [cyan]{csv_path}[/cyan]")
+
+    if len(ERROR_LIST) > 0:
+        console.print(
+            Panel(
+                Pretty(ERROR_LIST),
+                title="❗ Errors Encountered During Processing",
+                border_style="red",
+                padding=(1, 2),
+            )
+        )
+    else:
+        console.print(
+            Panel.fit(
+                Text("✅ All symlinks created successfully!", justify="center"),
+                title="Symlink Creation Complete",
+                border_style="green",
+            )
+        )
+
+
+if __name__ == "__main__":
+    pass

machineconfig/profile/create_links_export.py

@@ -0,0 +1,100 @@
+
+import typer
+from typing import Optional, Literal, Annotated, TypeAlias
+
+ON_CONFLICT_LOOSE: TypeAlias = Literal[
+    "throw-error", "t",
+    "overwrite-self-managed", "os",
+    "backup-self-managed", "bs",
+    "overwrite-default-path", "od",
+    "backup-default-path", "bd"
+    ]
+ON_CONFLICT_STRICT: TypeAlias = Literal["throw-error", "overwrite-self-managed", "backup-self-managed", "overwrite-default-path", "backup-default-path"]
+ON_CONFLICT_MAPPER: dict[str, ON_CONFLICT_STRICT] = {
+    "t": "throw-error",
+    "os": "overwrite-self-managed",
+    "bs": "backup-self-managed",
+    "od": "overwrite-default-path",
+    "bd": "backup-default-path",
+    "throw-error": "throw-error",
+    "overwrite-self-managed": "overwrite-self-managed",
+    "backup-self-managed": "backup-self-managed",
+    "overwrite-default-path": "overwrite-default-path",
+    "backup-default-path": "backup-default-path",
+    }
+
+
+def main_public_from_parser(method: Annotated[Literal["symlink", "s", "copy", "c"], typer.Option(..., "--method", "-m", help="Method to use for setting up the config file.")],
+                            on_conflict: Annotated[ON_CONFLICT_LOOSE, typer.Option(..., "--on-conflict", "-o", help="Action to take on conflict")] = "throw-error",
+                            which: Annotated[Optional[str], typer.Option(..., "--which", "-w", help="Specific items to process")] = "all",
+                            interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Run in interactive mode")] = False):
+    """Terminology:
+    SOURCE = Self-Managed-Config-File-Path
+    TARGET = Config-File-Default-Path
+    For public config files, the source always exists, because we know it comes from machineconfig repo."""
+    from machineconfig.profile.create_links import ConfigMapper, read_mapper
+    mapper_full = read_mapper()["public"]
+    if which is None:
+        assert interactive is True
+        from machineconfig.utils.options import choose_from_options
+        items_chosen = choose_from_options(msg="Which symlink to create?", options=list(mapper_full.keys()), tv=True, multi=True)
+    else:
+        assert interactive is False
+        if which == "all":
+            items_chosen = list(mapper_full.keys())
+        else:
+            items_chosen = which.split(",")
+    items_objections: dict[str, list[ConfigMapper]] = {item: mapper_full[item] for item in items_chosen if item in mapper_full}
+    if len(items_objections) == 0:
+        typer.echo("[red]Error:[/] No valid items selected.")
+        typer.Exit(code=1)
+        return
+    from machineconfig.profile.create_links import apply_mapper
+    from machineconfig.profile.create_helper import copy_assets_to_machine
+    copy_assets_to_machine(which="settings")  # config files live here and will be linked to.
+    method_map: dict[str, Literal["symlink", "copy"]] = {
+        "s": "symlink",
+        "symlink": "symlink",
+        "c": "copy",
+        "copy": "copy",
+    }
+    method = method_map[method]
+    apply_mapper(mapper_data=items_objections, on_conflict=ON_CONFLICT_MAPPER[on_conflict], method=method)
+
+
+def main_private_from_parser(method: Annotated[Literal["symlink", "s", "copy", "c"], typer.Option(..., "--method", "-m", help="Method to use for linking files")],
+                             on_conflict: Annotated[ON_CONFLICT_LOOSE, typer.Option(..., "--on-conflict", "-o", help="Action to take on conflict")] = "throw-error",
+                             which: Annotated[Optional[str], typer.Option(..., "--which", "-w", help="Specific items to process")] = "all",
+                             interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Run in interactive mode")] = False):
+    from machineconfig.profile.create_links import ConfigMapper, read_mapper
+    mapper_full = read_mapper()["private"]
+    if which is None:
+        if interactive is False:
+            typer.echo("[red]Error:[/] --which must be provided when not running in interactive mode.")
+            typer.Exit(code=1)
+            return
+        from machineconfig.utils.options import choose_from_options
+        items_chosen = choose_from_options(msg="Which symlink to create?", options=list(mapper_full.keys()), tv=True, multi=True)
+    else:
+        if interactive is True:
+            typer.echo("[yellow]Warning:[/] --which is provided, but its not allowed to be used together with --interactive. Ignoring --interactive flag.")
+            typer.Exit(code=0)
+            return
+        if which == "all":
+            items_chosen = list(mapper_full.keys())
+        else:
+            items_chosen = which.split(",")
+    items_objections: dict[str, list[ConfigMapper]] = {item: mapper_full[item] for item in items_chosen if item in mapper_full}
+    if len(items_objections) == 0:
+        typer.echo("[red]Error:[/] No valid items selected.")
+        typer.Exit(code=1)
+        return
+    from machineconfig.profile.create_links import apply_mapper
+    method_map: dict[str, Literal["symlink", "copy"]] = {
+        "s": "symlink",
+        "symlink": "symlink",
+        "c": "copy",
+        "copy": "copy",
+    }
+    method = method_map[method]
+    apply_mapper(mapper_data=items_objections, on_conflict=ON_CONFLICT_MAPPER[on_conflict], method=method)

machineconfig/profile/create_shell_profile.py

@@ -0,0 +1,147 @@
+"""shell"""
+
+from pathlib import Path
+
+
+
+def get_shell_profile_path() -> Path:
+    import platform
+    import subprocess
+    from rich.console import Console
+    from rich.panel import Panel
+    system = platform.system()
+    console = Console()
+    if system == "Windows":
+        result = subprocess.run(["pwsh", "-Command", "$PROFILE"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False)
+        if result.returncode == 0 and result.stdout.strip():
+            profile_path = Path(result.stdout.strip())
+        else:
+            print(f"Command failed with return code {result.returncode}")
+            print(f"stdout: {result.stdout}")
+            print(f"stderr: {result.stderr}")
+            raise ValueError(f"""Could not get profile path for Windows. Got stdout: {result.stdout}, stderr: {result.stderr}""")
+    elif system == "Linux":
+        profile_path = Path.home().joinpath(".bashrc")
+    elif system == "Darwin":
+        profile_path = Path.home().joinpath(".zshrc")
+    else:
+        raise ValueError(f"""Not implemented for this system {system}""")
+    console.print(Panel(f"""🐚 SHELL PROFILE | Working with path: `{profile_path}`""", title="[bold blue]Shell Profile[/bold blue]", border_style="blue"))
+    return profile_path
+
+
+def get_nu_shell_profile_path() -> Path:
+    import platform
+    from rich.console import Console
+    from rich.panel import Panel
+    system = platform.system()
+    console = Console()
+    if system == "Windows":
+        profile_path = Path.home().joinpath(r"AppData\Roaming\nushell")
+    elif system == "Linux":
+        profile_path = Path.home().joinpath(".config/nushell")
+    elif system == "Darwin":
+        profile_path = Path.home().joinpath("Library/Application Support/nushell")
+    else:
+        raise ValueError(f"""Not implemented for this system {system}""")
+    console.print(Panel(f"""🐚 NU SHELL PROFILE | Working with path: `{profile_path}`""", title="[bold cyan]Nu Shell Profile[/bold cyan]", border_style="cyan"))
+    return profile_path
+
+
+def create_default_shell_profile() -> None:
+    shell_profile_path = get_shell_profile_path()
+    import platform
+    import subprocess
+    from rich.console import Console
+    from rich.panel import Panel
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    from machineconfig.utils.path_extended import PathExtended
+    system = platform.system()
+    console = Console()
+    if not shell_profile_path.exists():
+        console.print(Panel(f"""🆕 PROFILE | Profile does not exist at `{shell_profile_path}`. Creating a new one.""", title="[bold blue]Profile[/bold blue]", border_style="blue"))
+        shell_profile_path.parent.mkdir(parents=True, exist_ok=True)
+        shell_profile_path.write_text("", encoding="utf-8")
+    shell_profile = shell_profile_path.read_text(encoding="utf-8")
+    from machineconfig.profile.create_helper import copy_assets_to_machine
+    copy_assets_to_machine("settings")  # init.ps1 or init.sh live here
+    copy_assets_to_machine("scripts")  # init scripts are going to reference those scripts.
+    shell_name = ""
+    if system == "Windows":
+        shell_name = "pwsh"
+        init_script = PathExtended(CONFIG_ROOT).joinpath("settings/shells/pwsh/init.ps1")
+        source_line = f""". {str(init_script.collapseuser(placeholder="$HOME"))}"""
+    elif system == "Linux":
+        shell_name = "bash"
+        init_script = PathExtended(CONFIG_ROOT).joinpath("settings/shells/bash/init.sh")
+        source_line = f"""source {str(init_script.collapseuser(placeholder="$HOME"))}"""
+    elif system == "Darwin":
+        shell_name = "zsh"
+        init_script = PathExtended(CONFIG_ROOT).joinpath("settings/shells/zsh/init.sh")
+        source_line = f"""source {str(init_script.collapseuser(placeholder="$HOME"))}"""
+    else:
+        raise ValueError(f"""Not implemented for this system {system}""")
+
+    was_shell_updated = False
+    if source_line in shell_profile:
+        console.print(Panel("🔄 PROFILE | Skipping init script sourcing - already present in profile", title="[bold blue]Profile[/bold blue]", border_style="blue"))
+    else:
+        console.print(Panel("📝 PROFILE | Adding init script sourcing to profile", title="[bold blue]Profile[/bold blue]", border_style="blue"))
+        shell_profile += "\n" + source_line + "\n"
+        if shell_name == "bash":
+            result = subprocess.run(["cat", "/proc/version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False)
+            if result.returncode == 0 and result.stdout:
+                version_info = result.stdout.lower()
+                is_wsl = "microsoft" in version_info or "wsl" in version_info
+                if is_wsl:
+                    shell_profile += "\ncd $HOME"
+                    console.print("📌 WSL detected - adding 'cd $HOME' to profile to avoid Windows filesystem")
+                    # Sync shell history between Windows and WSL
+                    # https://www.hanselman.com/blog/sharing-powershell-history-between-windows-and-wsl
+                    shell_profile += """
+# Sync shell history between Windows and WSL
+export PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND$'\\n'}history -a; history -c; history -r"
+"""
+        was_shell_updated = True
+    if was_shell_updated:
+        shell_profile_path.parent.mkdir(parents=True, exist_ok=True)
+        shell_profile_path.write_text(shell_profile, encoding="utf-8")
+        console.print(Panel("✅ Profile updated successfully", title="[bold blue]Profile[/bold blue]", border_style="blue"))
+
+
+def create_nu_shell_profile() -> None:
+    from rich.console import Console
+    from rich.panel import Panel
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    from machineconfig.utils.path_extended import PathExtended
+    console = Console()
+    nu_profile_path = get_nu_shell_profile_path()
+    config_dir = nu_profile_path
+    config_file = config_dir.joinpath("config.nu")
+    if not config_dir.exists():
+        console.print(Panel(f"""🆕 NU SHELL CONFIG | Config directory does not exist at `{config_dir}`. Creating a new one.""", title="[bold cyan]Nu Shell Config[/bold cyan]", border_style="cyan"))
+        config_dir.mkdir(parents=True, exist_ok=True)
+    if not config_file.exists():
+        console.print(Panel(f"""🆕 NU SHELL CONFIG | config.nu file does not exist at `{config_file}`. Creating a new one.""", title="[bold cyan]Nu Shell Config[/bold cyan]", border_style="cyan"))
+        config_file.write_text("", encoding="utf-8")
+    config_content = config_file.read_text(encoding="utf-8")
+    from machineconfig.profile.create_helper import copy_assets_to_machine
+    copy_assets_to_machine("settings")
+    copy_assets_to_machine("scripts")
+    init_script = PathExtended(CONFIG_ROOT).joinpath("settings/shells/nushell/init.nu")
+    source_line = f"""use {str(init_script)}"""
+    was_config_updated = False
+    if source_line in config_content:
+        console.print(Panel("🔄 NU SHELL CONFIG | Skipping init script sourcing - already present in config.nu", title="[bold cyan]Nu Shell Config[/bold cyan]", border_style="cyan"))
+    else:
+        console.print(Panel("📝 NU SHELL CONFIG | Adding init script sourcing to config.nu", title="[bold cyan]Nu Shell Config[/bold cyan]", border_style="cyan"))
+        config_content += "\n" + source_line + "\n"
+        was_config_updated = True
+    if was_config_updated:
+        config_dir.mkdir(parents=True, exist_ok=True)
+        config_file.write_text(config_content, encoding="utf-8")
+        console.print(Panel("✅ Nu shell config updated successfully", title="[bold cyan]Nu Shell Config[/bold cyan]", border_style="cyan"))
+
+
+if __name__ == "__main__":
+    pass