machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/scripts/python/sessions.py

@@ -0,0 +1,167 @@
+
+from typing import Optional, Literal, Annotated
+import typer
+
+def balance_load(layout_path: Annotated[str, typer.Argument(..., help="Path to the layout.json file")],
+           max_thresh: Annotated[int, typer.Option(..., "--max-threshold", "-m", help="Maximum tabs per layout")],
+           thresh_type: Annotated[Literal['number', 'n', 'weight', 'w'], typer.Option(..., "--threshold-type", "-t", help="Threshold type")],
+           breaking_method: Annotated[Literal['moreLayouts', 'ml', 'combineTabs', 'ct'], typer.Option(..., "--breaking-method", "-b", help="Breaking method")],
+           output_path: Annotated[Optional[str], typer.Option(..., "--output-path", "-o", help="Path to write the adjusted layout.json file")] = None):
+    """Adjust layout file to limit max tabs per layout, etc."""
+    thresh_type_resolved: dict[str, Literal['number', 'weight']] = {
+        'number': 'number',
+        'n': 'number',
+        'weight': 'weight',
+        'w': 'weight'
+    }
+    breaking_method_resolved: dict[str, Literal['moreLayouts', 'combineTabs']] = {
+        'moreLayouts': 'moreLayouts',
+        'ml': 'moreLayouts',
+        'combineTabs': 'combineTabs',
+        'ct': 'combineTabs'
+    }
+    from pathlib import Path
+    layout_path_obj = Path(layout_path).expanduser().absolute()
+
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    import json
+    layoutfile: LayoutsFile = json.loads(layout_path_obj.read_text())
+    layout_configs = layoutfile["layouts"]
+    from machineconfig.cluster.sessions_managers.utils.load_balancer import limit_tab_num
+    new_layouts = limit_tab_num(layout_configs=layout_configs, max_thresh=max_thresh, threshold_type=thresh_type_resolved[thresh_type], breaking_method=breaking_method_resolved[breaking_method])
+    layoutfile["layouts"] = new_layouts
+    target_file = Path(output_path) if output_path is not None else layout_path_obj.parent / f'{layout_path_obj.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json'
+    target_file.parent.mkdir(parents=True, exist_ok=True)
+    target_file.write_text(data=json.dumps(layoutfile, indent=4), encoding="utf-8")
+    typer.echo(f"Adjusted layout saved to {target_file}")
+
+
+def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[str]], select_interactively: bool) -> list["LayoutConfig"]:
+    import json
+    from machineconfig.utils.options import choose_from_options
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    from pathlib import Path
+    layout_file: LayoutsFile = json.loads(Path(layouts_json_file).read_text(encoding="utf-8"))
+    if len(layout_file["layouts"]) == 0:
+        raise ValueError(f"No layouts found in {layouts_json_file}")
+    if selected_layouts_names is None:  # choose all, or interactively
+        if not select_interactively:
+            return layout_file["layouts"]
+        options = [layout["layoutName"] for layout in layout_file["layouts"]]
+        from machineconfig.utils.options import choose_from_options
+        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
+    print(f"Selected layout(s): {selected_layouts_names}")
+    # Extract the configs from the names:
+    layouts_chosen: list[LayoutConfig] = []
+    for name in selected_layouts_names:
+        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
+        if layout_chosen is None:
+            layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
+        if layout_chosen is None:
+            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
+        layouts_chosen.append(layout_chosen)
+    return layouts_chosen
+
+
+def find_layout_file(layout_path: str, ) -> str:
+    from machineconfig.utils.path_helper import search_for_files_of_interest
+    from machineconfig.utils.options import choose_from_options
+    from machineconfig.utils.path_helper import match_file_name, sanitize_path
+    from pathlib import Path
+    path_obj = sanitize_path(layout_path)
+    if not path_obj.exists():
+        choice_file = match_file_name(sub_string=layout_path, search_root=Path.cwd(), suffixes={".json"})
+    elif path_obj.is_dir():
+        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
+        files = search_for_files_of_interest(path_obj, suffixes={".py", ".sh", ".ps1"})
+        print(f"🔍 Got #{len(files)} results.")
+        choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
+        choice_file = Path(choice_file).expanduser().absolute()
+    else:
+        choice_file = path_obj
+    return str(choice_file)
+
+
+def run(ctx: typer.Context,
+           layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
+        max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 10,
+        max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 10,
+        sleep_inbetween: Annotated[float, typer.Option(..., "--sleep-inbetween", "-si", help="Sleep time in seconds between launching layouts")] = 1.0,
+        monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
+        parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
+        kill_upon_completion: Annotated[bool, typer.Option(..., "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)")] = False,
+        choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
+        choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False
+        ):
+    """
+    Launch terminal sessions based on a layout configuration file.
+    """
+    if layout_path is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+    layout_path_resolved = find_layout_file(layout_path=layout_path)
+    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively)
+
+    # ============= Basic sanity checks =============
+    if parallel and len(layouts_selected) > max_layouts:
+        raise ValueError(f"Number of layouts {len(layouts_selected)} exceeds the maximum allowed {max_layouts}. Please adjust your layout file.")
+    for a_layout in layouts_selected:
+        if len(a_layout["layoutTabs"]) > max_tabs:
+            typer.echo(f"Layout '{a_layout.get('layoutName', 'Unnamed')}' has {len(a_layout['layoutTabs'])} tabs which exceeds the max of {max_tabs}.")
+            confirm = typer.confirm("Do you want to proceed with launching this layout?", default=False)
+            if not confirm:
+                typer.echo("Aborting launch.")
+                raise typer.Exit(0)
+    import time
+    import platform
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+        if not parallel: iterable = [[item] for item in layouts_selected]
+        else: iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = ZellijLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions(poll_interval=2, poll_seconds=2)
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:  # Don't sleep after the last layout
+                time.sleep(sleep_inbetween)
+    elif platform.system() == "Windows":
+        from machineconfig.cluster.sessions_managers.wt_local_manager import WTLocalManager
+        if not parallel: iterable = [[item] for item in layouts_selected]
+        else: iterable = [layouts_selected]
+        for i, a_layouts in enumerate(iterable):
+            manager = WTLocalManager(session_layouts=a_layouts)
+            manager.start_all_sessions()
+            if monitor:
+                manager.run_monitoring_routine(wait_ms=2000)
+                if kill_upon_completion:
+                    manager.kill_all_sessions()
+            if i < len(layouts_selected) - 1:  # Don't sleep after the last layout
+                time.sleep(sleep_inbetween)
+    else:
+        print(f"❌ Unsupported platform: {platform.system()}")
+
+
+def get_app():
+    layouts_app = typer.Typer(help="Layouts management subcommands", no_args_is_help=True, add_help_option=False, add_completion=False)
+    from machineconfig.scripts.python.helpers_sessions.sessions_multiprocess import create_from_function
+    layouts_app.command("create-from-function", no_args_is_help=True, help="[c] Create a layout from a function")(create_from_function)
+    layouts_app.command("c", no_args_is_help=True, help="Create a layout from a function", hidden=True)(create_from_function)
+    layouts_app.command("run", no_args_is_help=True, help="[r] Run the selected layout(s)")(run)
+    layouts_app.command("r", no_args_is_help=True, help="Run the selected layout(s)", hidden=True)(run)
+    layouts_app.command("balance-load", no_args_is_help=True, help="[b] Balance the load across sessions")(balance_load)
+    layouts_app.command("b", no_args_is_help=True, help="Balance the load across sessions", hidden=True)(balance_load)
+
+    return layouts_app
+
+
+def main():
+    layouts_app = get_app()
+    layouts_app()
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig

machineconfig/scripts/python/terminal.py

@@ -0,0 +1,127 @@
+import typer
+from typing import Annotated
+
+
+def strip_ansi_codes(text: str) -> str:
+    """Remove ANSI color codes from text."""
+    import re
+    return re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text)
+
+
+def choose_zellij_session(
+        new_session: Annotated[bool, typer.Option("--new-session", "-n", help="Create a new Zellij session instead of attaching to an existing one.", show_default=True)] = False,
+        kill_all: Annotated[bool, typer.Option("--kill-all", "-k", help="Kill all existing Zellij sessions before creating a new one.", show_default=True)] = False):
+
+    if new_session:
+        cmd = """
+    zellij --layout st2
+    """
+        if kill_all:
+            cmd = f"""zellij kill-sessions
+    {cmd}"""
+        from machineconfig.utils.code import exit_then_run_shell_script
+        exit_then_run_shell_script(script=cmd, strict=True)
+        typer.Exit()
+        return
+    cmd = "zellij list-sessions"
+    import subprocess
+    sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    # filter out empty lines and keep raw lines (they contain creation info)
+    sessions = [s for s in sessions if s.strip()]
+    sessions.sort(key=lambda s: "EXITED" in s)
+    if "current" in sessions:
+        print("Already in a Zellij session, avoiding nesting and exiting.")
+        raise typer.Exit()
+    if len(sessions) == 0:
+        print("No Zellij sessions found, creating a new one.")
+        result = """zellij --layout st2"""
+    elif len(sessions) == 1:
+        session = sessions[0].split(" [Created")[0]
+        print(f"Only one Zellij session found: {session}, attaching to it.")
+        result = f"zellij attach {session}"
+    else:
+        from machineconfig.utils.options import choose_from_options
+        # Artificially inject a "NEW SESSION" option so the user can create one from the list
+        NEW_SESSION_LABEL = "NEW SESSION"
+        options = [NEW_SESSION_LABEL] + sessions
+        session = choose_from_options(msg="Choose a Zellij session to attach to:", multi=False, options=options, fzf=True)
+        # If the user chose the artificial option, start a new session (same as --new-session)
+        if session == NEW_SESSION_LABEL:
+            cmd = "zellij --layout st2"
+            if kill_all:
+                cmd = f"zellij kill-sessions\n{cmd}"
+            from machineconfig.utils.code import exit_then_run_shell_script
+            exit_then_run_shell_script(cmd, strict=True)
+            raise typer.Exit()
+        session = session.split(" [Created")[0]
+        result = f"zellij attach {session}"
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(result, strict=True)
+
+
+
+def get_session_tabs() -> list[tuple[str, str]]:
+    cmd = "zellij list-sessions"
+    import subprocess
+    sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
+    sessions = [strip_ansi_codes(s) for s in sessions]
+    active_sessions = [s for s in sessions if "EXITED" not in s]
+    result: list[tuple[str, str]] = []
+    for session_line in active_sessions:
+        session_name = session_line.split(" [Created")[0].strip()
+        # Query tab names for the session
+        tab_cmd = f"zellij  --session {session_name} action query-tab-names"
+        try:
+            tabs: list[str] = subprocess.check_output(tab_cmd, shell=True).decode().strip().split("\n")
+            for tab in tabs:
+                if tab.strip():
+                    result.append((session_name, tab.strip()))
+        except subprocess.CalledProcessError:
+            # Skip if query fails
+            continue
+    print(result)
+    return result
+
+
+def start_wt(layout_name: Annotated[str, typer.Argument(help="Layout name to start.")]):
+    from pathlib import Path
+    layouts_file = Path.home().joinpath("dotfiles/machineconfig/layouts.json")
+    if not layouts_file.exists():
+        typer.echo(f"❌ Layouts file not found: {layouts_file}")
+        # available
+        raise typer.Exit(code=1)
+    import json
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    layouts_data: LayoutsFile = json.loads(layouts_file.read_text(encoding="utf-8"))
+    chosen_layout = next((a_layout for a_layout in layouts_data["layouts"] if a_layout["layoutName"] == layout_name), None)
+    if not chosen_layout:
+        typer.echo(f"❌ Layout '{layout_name}' not found in layouts file.")
+        available_layouts = [a_layout["layoutName"] for a_layout in layouts_data["layouts"]]
+        typer.echo(f"Available layouts: {', '.join(available_layouts)}")
+        raise typer.Exit(code=1)
+    from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+    run_wt_layout(layout_config=chosen_layout)
+    # cmd = f'powershell -ExecutionPolicy Bypass -File "./{layout_name}_layout.ps1"'
+    # from machineconfig.utils.code import exit_then_run_shell_script
+    # exit_then_run_shell_script(cmd, strict=True)
+
+
+def get_app():
+    app = typer.Typer(help="🖥️ Terminal utilities", no_args_is_help=True, add_help_option=False)
+    app.command(name="attach-to-zellij", no_args_is_help=False, help="[z] Choose a Zellij session to attach to")(choose_zellij_session)
+    app.command(name="z", hidden=True, no_args_is_help=False, help="[z] Choose a Zellij session to attach to")(choose_zellij_session)
+
+    app.command(name="start-wt", no_args_is_help=True, help="[w] Start a Windows Terminal layout by name.")(start_wt)
+    app.command(name="w", hidden=True, no_args_is_help=True, help="[w] Start a Windows Terminal layout by name.")(start_wt)
+
+    app.command(name="get-session-tabs", no_args_is_help=False, help="[zt] Get all Zellij session tabs.")(get_session_tabs)
+    app.command(name="zt", hidden=True, no_args_is_help=False, help="[zt] Get all Zellij session tabs.")(get_session_tabs)
+    return app
+
+def main():
+    app = get_app()
+    app()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/utils.py

@@ -0,0 +1,66 @@
+
+
+from machineconfig.scripts.python.helpers_devops.cli_utils import merge_pdfs, compress_pdf
+from machineconfig.scripts.python.helpers_utils.path import edit_file_with_hx, get_machine_specs, init_project, path
+from machineconfig.scripts.python.helpers_utils.download import download
+import typer
+from typing import Annotated
+
+
+def kill_process(
+        # name: Annotated[Optional[str], typer.Option(..., "--name", "-n", help="Name of the process to kill")],
+                #  command: Annotated[str, typer.Option(..., "--command", "-c", help="Match by command line instead of process name")] = "",
+                 interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactively choose the process to kill")] = True):
+    from machineconfig.utils.procs import main, ProcessManager
+    if interactive:
+        main()
+        return
+    _ = ProcessManager
+    # pm = ProcessManager()
+    # if command:
+    #     pm.filter_and_kill(name=command
+                        #    )
+
+
+def upgrade_packages():
+    from machineconfig.utils.upgrade_packages import generate_uv_add_commands
+    from pathlib import Path
+    generate_uv_add_commands(pyproject_path=Path.cwd() / "pyproject.toml", output_path=Path.cwd() / "pyproject_init.sh")
+
+
+def get_app() -> typer.Typer:
+    app = typer.Typer(help="🛠️ utilities operations", no_args_is_help=True, add_help_option=False, add_completion=False)
+    app.command(name="kill-process", no_args_is_help=False, help="⚔️ [k] Choose a process to kill")(kill_process)
+    app.command(name="k", no_args_is_help=False, help="Choose a process to kill", hidden=True)(kill_process)
+
+    app.command("path", no_args_is_help=False, help="📚 [p] NAVIGATE PATH variable with TUI")(path)
+    app.command("p", no_args_is_help=False, help="NAVIGATE PATH variable with TUI", hidden=True)(path)
+
+    app.command(name="upgrade-packages", no_args_is_help=False, help="⬆️ [up] Upgrade project dependencies.")(upgrade_packages)
+    app.command(name="up", no_args_is_help=False, hidden=True)(upgrade_packages)
+
+    app.command(name="download", no_args_is_help=True, help="⬇️ [d] Download a file from a URL and optionally decompress it.")(download)
+    app.command(name="d", no_args_is_help=True, hidden=True)(download)
+    app.command(name="get-machine-specs", no_args_is_help=False, help="💻 [g] Get machine specifications.")(get_machine_specs)
+    app.command(name="g", no_args_is_help=False, hidden=True)(get_machine_specs)
+    app.command(name="init-project", no_args_is_help=False, help="🚀 [i] Initialize a project with a uv virtual environment and install dev packages.")(init_project)
+    app.command(name="i", no_args_is_help=False, hidden=True)(init_project)
+    app.command(name="edit", no_args_is_help=False, help="✏️ [e] Open a file in the default editor.")(edit_file_with_hx)
+    app.command(name="e", no_args_is_help=False, hidden=True)(edit_file_with_hx)
+
+    app.command(name="pdf-merge", no_args_is_help=True, help="📄 [pm] Merge two PDF files into one.")(merge_pdfs)
+    app.command(name="pm", no_args_is_help=True, hidden=True)(merge_pdfs)
+    app.command(name="pdf-compress", no_args_is_help=True, help="📦 [pc] Compress a PDF file.")(compress_pdf)
+    app.command(name="pc", no_args_is_help=True, hidden=True)(compress_pdf)
+
+    # app.command(name="copy", no_args_is_help=True, help="[c] Copy files or directories.")(copy)
+    # app.command(name="c", no_args_is_help=True, hidden=True)(copy)
+
+    return app
+
+# def func():
+#     import pycr
+
+def main():
+    app = get_app()
+    app()

machineconfig/scripts/windows/mounts/Restore-ThunderbirdProfile.ps1

@@ -0,0 +1,92 @@
+
+<#
+.SYNOPSIS
+    Restores a Thunderbird profile from a backup.
+
+.DESCRIPTION
+    This script automates the restoration of a Thunderbird profile. It finds the
+    default backup profile located in ~/.thunderbird and copies its contents to
+    the active Thunderbird profile folder in AppData/Roaming.
+
+    WARNING: This script will overwrite the current active Thunderbird profile.
+    Ensure Thunderbird is closed before running.
+#>
+
+# --- Configuration ---
+$ErrorActionPreference = "Stop"
+
+# --- Script ---
+
+# 1. Define the root paths for backup and active profiles
+$thunderbirdBackupRoot = "$env:USERPROFILE\.thunderbird"
+$thunderbirdAppdataRoot = "$env:APPDATA\Thunderbird"
+
+Write-Host "Thunderbird Profile Restore Script"
+Write-Host "-----------------------------------"
+
+# 2. Find the default profile path from the backup's profiles.ini
+try {
+    $backupIniPath = Join-Path $thunderbirdBackupRoot "profiles.ini"
+    $backupProfileRelativePath = (Get-Content $backupIniPath | Select-String -Pattern '^Path=' | Select-Object -First 1) -replace '^Path=', ''
+    $backupProfileFullPath = Join-Path $thunderbirdBackupRoot $backupProfileRelativePath
+    Write-Host "Found backup profile: $backupProfileFullPath" -ForegroundColor Green
+}
+catch {
+    Write-Error "Could not find or read the backup profiles.ini at '$backupIniPath'."
+    exit 1
+}
+
+# 3. Find the default profile path from the active installation's profiles.ini
+try {
+    $activeIniPath = Join-Path $thunderbirdAppdataRoot "profiles.ini"
+    $activeProfileRelativePath = (Get-Content $activeIniPath | Select-String -Pattern '^Path=' | Select-Object -First 1) -replace '^Path=', ''
+    $activeProfileFullPath = Join-Path $thunderbirdAppdataRoot $activeProfileRelativePath
+    Write-Host "Found active profile: $activeProfileFullPath" -ForegroundColor Green
+}
+catch {
+    Write-Error "Could not find or read the active profiles.ini at '$activeIniPath'."
+    exit 1
+}
+
+# 4. Safety Check: Confirm both profile paths exist
+if (-not (Test-Path -Path $backupProfileFullPath -PathType Container)) {
+    Write-Error "Backup profile directory does not exist: $backupProfileFullPath"
+    exit 1
+}
+if (-not (Test-Path -Path $activeProfileFullPath -PathType Container)) {
+    Write-Error "Active profile directory does not exist: $activeProfileFullPath"
+    exit 1
+}
+
+# 5. CRITICAL: Get user confirmation before proceeding
+Write-Warning "This will completely overwrite the profile at '$activeProfileFullPath' with the contents of the backup."
+$confirmation = Read-Host "Are you absolutely sure you want to continue? (y/n)"
+
+if ($confirmation -ne 'y') {
+    Write-Host "Operation cancelled by user." -ForegroundColor Yellow
+    exit 0
+}
+
+# 6. Ensure Thunderbird is not running
+Write-Host "Checking for running Thunderbird process..."
+$thunderbirdProcess = Get-Process thunderbird -ErrorAction SilentlyContinue
+if ($thunderbirdProcess) {
+    Write-Host "Closing Thunderbird to prevent file conflicts..."
+    Stop-Process -InputObject $thunderbirdProcess -Force
+    Start-Sleep -Seconds 3 # Give it a moment to close gracefully
+} else {
+    Write-Host "Thunderbird is not running. Good."
+}
+
+# 7. Copy the backup profile to the active profile directory using robocopy
+Write-Host "Starting profile restoration... (This may take a while)"
+try {
+    robocopy $backupProfileFullPath $activeProfileFullPath /MIR /E /IS /IT /NFL /NDL /NJH /NJS /nc /ns /np
+    Write-Host "Profile restoration complete!" -ForegroundColor Green
+    Write-Host "You can now start Thunderbird."
+}
+catch {
+    Write-Error "An error occurred during the file copy operation."
+    exit 1
+}
+

machineconfig/scripts/windows/{mount_nfs.ps1 → mounts/mount_nfs.ps1}

@@ -17,10 +17,8 @@ $sharePath=''
 $driveLetter=''
 $options = "rw,sec=sys,no_subtree_check"
 
-# . activate_ve
-. $HOME/code/machineconfig/.venv/Scripts/activate.ps1
 
-python -m machineconfig.scripts.python.mount_nfs
+uv run python -m machineconfig.scripts.python.mount_nfs
 . $HOME/tmp_results/shells/python_return_command.ps1
 
 # Configure NFS server

machineconfig/scripts/windows/{mount_ssh.ps1 → mounts/mount_ssh.ps1}

@@ -7,7 +7,7 @@ $user = ''
 $sharePath = ''
 $driveLetter = ''
 
-uv run --python 3.13 --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.mount_ssh
+uv run --python 3.14 --with "machineconfig>=7.69" python -m machineconfig.scripts.python.mount_ssh
 
 net use T: \\sshfs.kr\$user@$host.local
 # this worked: net use T: \\sshfs\alex@alex-p51s-5.local

machineconfig/scripts/windows/{share_smb.ps1 → mounts/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
 }

machineconfig/scripts/windows/wrap_mcfg.ps1

@@ -0,0 +1,60 @@
+function wrap_in_shell_script {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$Command,
+        
+        [Parameter(ValueFromRemainingArguments=$true)]
+        [string[]]$Arguments
+    )
+    
+    # Generate a random name (based on current timestamp hashed with SHA256)
+    # Compute SHA256 of the timestamp string (don't pipe the string to Get-FileHash
+    # because that attempts to treat the input as a path). Take the first 16 hex
+    # chars as the random name.
+    $ts = Get-Date -Format o
+    try {
+        $sha = [System.Security.Cryptography.SHA256]::Create()
+        $bytes = [System.Text.Encoding]::UTF8.GetBytes($ts)
+        $hashBytes = $sha.ComputeHash($bytes)
+        $hash = [System.BitConverter]::ToString($hashBytes).Replace("-", "").ToLower()
+        $randomName = $hash.Substring(0, 16)
+    } finally {
+        if ($sha) { $sha.Dispose() }
+    }
+
+    # Define the output path
+    $env:OP_PROGRAM_PATH = "$HOME/tmp_results/tmp_scripts/machineconfig/${randomName}.ps1"
+
+    # Run the specified command with its arguments
+    & $Command @Arguments
+
+    # Check if the file exists
+    if (Test-Path $env:OP_PROGRAM_PATH) {
+        Write-Host "🚀 Taking over from python script @ $env:OP_PROGRAM_PATH"
+        try {
+            bat --style=full --theme=OneHalfDark --paging=never "$env:OP_PROGRAM_PATH"
+        } catch {
+            Write-Host "⚠️ Warning: Failed to display script content with 'bat'. Proceeding to execute the script."
+        }
+        & $env:OP_PROGRAM_PATH
+        Write-Host "✅ '$Command' execution completed."
+    } else {
+        Write-Host "✅ '$Command' execution completed."
+    }
+
+    # Clean up the temporary environment variable so it doesn't leak to other processes/sessions
+    try {
+        Remove-Item Env:\OP_PROGRAM_PATH -ErrorAction SilentlyContinue
+    } catch {
+        # best-effort cleanup; ignore any errors
+    }
+
+    # Also explicitly clear the variable in the current process
+    $env:OP_PROGRAM_PATH = $null
+}
+
+# Call the function with any arguments passed to the script
+if ($args.Count -gt 0) {
+    wrap_in_shell_script @args
+}
+

machineconfig/settings/broot/br.sh

@@ -1,7 +1,5 @@
 #!/bin/bash
-#=======================================================================
 # 🌳 BROOT SHELL INTEGRATION 🌳
-#=======================================================================
 # This script was automatically generated by the broot program
 # More information can be found in https://github.com/Canop/broot
 # 
@@ -40,7 +38,6 @@ function br {
     fi
 }
 
-#=======================================================================
 # ℹ️ USAGE:
 #    br [options]
 #
@@ -48,4 +45,3 @@ function br {
 #    br                 # Open broot in the current directory
 #    br /path/to/dir    # Open broot in the specified directory
 #    br -h              # Show broot help
-#=======================================================================

machineconfig/settings/broot/conf.toml

@@ -2,4 +2,4 @@
 
 terminal_title = "{file} 🐄"
 
-capture_mouse: false
+capture_mouse = false

machineconfig/settings/helix/config.toml

@@ -25,3 +25,19 @@ enable = true
 max-wrap = 25 # increase value to reduce forced mid-word wrapping
 max-indent-retain = 0
 wrap-indicator = ""  # set wrap-indicator to "" to hide it
+
+
+# https://yazi-rs.github.io/docs/tips#helix-with-zellij
+# ~/.config/helix/config.toml
+[keys.normal]
+C-y = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh open %{buffer_name}"
+    
+# ~/.config/helix/config.toml
+
+# [keys.normal.C-y]
+# Open the file(s) in the current window
+# y = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh open %{buffer_name}"
+# Open the file(s) in a vertical split
+# v = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh vsplit %{buffer_name}"
+# Open the file(s) in a horizontal split
+# h = ":sh zellij run -n Yazi -c -f -x 10%% -y 10%% --width 80%% --height 80%% -- bash ~/.config/helix/yazi-picker.sh hsplit %{buffer_name}"

machineconfig/settings/helix/languages.toml

@@ -1,13 +1,22 @@
-# adopted from https://github.com/helix-editor/helix/wiki/How-to-install-the-default-language-servers#python---pyright--ruff--black
+# adopted from https://github.com/helix-editor/helix/wiki/Language-Server-Configurations
 # adopted from https://github.com/helix-editor/helix/discussions/6623
-# You will need: npm install pyright -g; pip install ruff-lsp; pip install black
+# You will need: uv add --dev pylsp-mypy python-lsp-server[all] pyright ruff-lsp
 
 [[language]]
 name = "python"
-language-servers = [ "pyright", "ruff" ]
+language-servers = ["pylsp", "pyright", "ruff", "pyrefly"]
+
+[language-server.pyrefly]
+command = "pyrefly"
+args = [ "lsp" ]
+
+[language-server.pylsp.config.pylsp]
+plugins.pylsp_mypy.enabled = true
+plugins.pylsp_mypy.live_mode = true
+
 
 [language-server.pyright.config.python.analysis]
-typeCheckingMode = "basic"
+typeCheckingMode = "strict"
 
 [language-server.ruff]
 command = "ruff-lsp"

machineconfig/settings/helix/yazi-picker.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+paths=$(yazi "$2" --chooser-file=/dev/stdout | while read -r; do printf "%q " "$REPLY"; done)
+
+if [[ -n "$paths" ]]; then
+	zellij action toggle-floating-panes
+	zellij action write 27 # send <Escape> key
+	zellij action write-chars ":$1 $paths"
+	zellij action write 13 # send <Enter> key
+else
+	zellij action toggle-floating-panes
+fi

machineconfig/settings/lf/linux/exe/lfcd.sh

@@ -13,6 +13,7 @@
 #     bind '"\C-o":"lfcd\C-m"'  # bash
 #     bindkey -s '^o' 'lfcd\n'  # zsh
 #
+
 lfcd () {
     # 🔄 Create temporary file for directory tracking
     tmp="$(mktemp)"