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

machineconfig/scripts/python/sessions.py

@@ -1,32 +1,56 @@
 
-from pathlib import Path
 from typing import Optional, Literal, Annotated
 import typer
 
-def balance_load(layout_path: Annotated[Path, typer.Argument(..., help="Path to the layout.json file")],
-           max_thresh: Annotated[int, typer.Option(..., help="Maximum tabs per layout")],
-           thresh_type: Annotated[Literal['number', 'weight'], typer.Option(..., help="Threshold type")],
-           breaking_method: Annotated[Literal['moreLayouts', 'combineTabs'], typer.Option(..., help="Breaking method")],
-           output_path: Annotated[Optional[Path], typer.Option(..., help="Path to write the adjusted layout.json file")] = None):
+
+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.read_text())
+    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, breaking_method=breaking_method)
+    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 = output_path if output_path is not None else layout_path.parent / f'{layout_path.stem}_adjusted_{max_thresh}_{thresh_type}_{breaking_method}.json'
+    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: Path, selected_layouts_names: Optional[list[str]], select_interactively: bool) -> list["LayoutConfig"]:
+def select_layout(layouts_json_file: str, selected_layouts_names: Optional[list[str]], select_interactively: bool,
+                  subsitute_home: bool
+                  ) -> list["LayoutConfig"]:
     import json
     from machineconfig.utils.options import choose_from_options
     from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
-    layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
+    from pathlib import Path
+    json_str = Path(layouts_json_file).read_text(encoding="utf-8")
+    if subsitute_home:
+        json_str = json_str.replace("~", str(Path.home())).replace("$HOME", str(Path.home()))
+        json_str = json_str.replace("""Command": "f """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg fire """)
+        json_str = json_str.replace("""Command": "s """, """Command": "~/.config/machineconfig/scripts/wrap_mcfg sessions """)
+
+    layout_file: LayoutsFile = json.loads(json_str)
     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
@@ -34,7 +58,7 @@ def select_layout(layouts_json_file: Path, selected_layouts_names: Optional[list
             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")
+        selected_layouts_names = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", tv=True, msg="Choose one option")
     print(f"Selected layout(s): {selected_layouts_names}")
     # Extract the configs from the names:
     layouts_chosen: list[LayoutConfig] = []
@@ -49,35 +73,36 @@ def select_layout(layouts_json_file: Path, selected_layouts_names: Optional[list
     return layouts_chosen
 
 
-def find_layout_file(layout_path: str, ) -> Path:
-    from machineconfig.utils.path_extended import PathExtended
-    from machineconfig.scripts.python.helpers_fire.helpers4 import search_for_files_of_interest
+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=PathExtended.cwd(), suffixes={".json"})
+        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)
+        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 = PathExtended(choice_file)
+        choice_file = choose_from_options(multi=False, options=files, tv=True, msg="Choose one option")
+        choice_file = Path(choice_file).expanduser().absolute()
     else:
         choice_file = path_obj
-    return choice_file
+    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(..., 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(..., 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(..., help="Sleep time in seconds between launching layouts")] = 1.0,
+        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", "-ia", help="Select layouts interactively")] = False
+        choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
+        subsitute_home: Annotated[bool, typer.Option(..., "--substitute-home", "-sh", help="Substitute ~ and $HOME in layout file with actual home directory path")] = False,
         ):
     """
     Launch terminal sessions based on a layout configuration file.
@@ -86,7 +111,7 @@ def run(ctx: typer.Context,
         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)
+    layouts_selected = select_layout(layouts_json_file=layout_path_resolved, selected_layouts_names=choose.split(",") if choose else None, select_interactively=choose_interactively, subsitute_home=subsitute_home)
 
     # ============= Basic sanity checks =============
     if parallel and len(layouts_selected) > max_layouts:
@@ -130,16 +155,60 @@ def run(ctx: typer.Context,
         print(f"❌ Unsupported platform: {platform.system()}")
 
 
+def create_template(name: Annotated[Optional[str], typer.Argument(..., help="Name of the layout template to create")] = None,
+                    num_tabs: Annotated[int, typer.Option(..., "--num-tabs", "-t", help="Number of tabs to include in the template")] = 3,
+                    ):
+    """Create a layout template file."""
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile, TabConfig
+    from pathlib import Path
+    tabs: list[TabConfig] = []
+    for i in range(1, num_tabs + 1):
+        tab: TabConfig = {
+            "tabName": f"Tab{i}",
+            "startDir": "~/" + str(Path.cwd().relative_to(Path.home())),
+            "command": "bash",
+        }
+        tabs.append(tab)
+    layouts: list[LayoutConfig] = [
+        {
+            "layoutName": f"{Path.cwd().name}Layout",
+            "layoutTabs": tabs,
+        }
+    ]
+    file: LayoutsFile = {
+        "$schema": "https://bit.ly/cfglayout",  # type: ignore
+        "version": "0.1",
+        "layouts": layouts
+    }
+    import json
+    json_string = json.dumps(file, indent=4)
+    if name is None:
+        layout_path = Path.cwd() / "layout.json"
+    else:
+        layout_path = Path.cwd() / (name.replace(".json", "") + ".json")
+    layout_path.parent.mkdir(parents=True, exist_ok=True)
+    if layout_path.exists():
+        print(f"❌ File {layout_path} already exists. Aborting to avoid overwriting.")
+        return
+    layout_path.write_text(json_string, encoding="utf-8")
+    print(f"✅ Created layout template at {layout_path}")
+
+
 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)
 
+    layouts_app.command("create-template", no_args_is_help=False, help="[t] Create a layout template file")(create_template)
+    layouts_app.command("t", no_args_is_help=False, help="Create a layout template file", hidden=True)(create_template)
     return layouts_app
 
 

machineconfig/scripts/python/terminal.py

@@ -0,0 +1,133 @@
+
+import typer
+from typing import Annotated, Optional
+
+
+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(
+        name: Annotated[Optional[str], typer.Argument(help="Name of the Zellij session to attach to. If not provided, a list will be shown to choose from.")] = None,
+        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 name is not None:
+        result = f"zellij attach {name}"
+        from machineconfig.utils.code import exit_then_run_shell_script
+        exit_then_run_shell_script(result, strict=True)
+
+    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_name = sessions[0].split(" [Created")[0]
+        print(f"Only one Zellij session found: {session_name}, attaching to it.")
+        result = f"zellij attach {session_name}"
+    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_name = choose_from_options(msg="Choose a Zellij session to attach to:", multi=False, options=options, tv=True)
+        if session_name == 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_name = session_name.split(" [Created")[0]
+        result = f"zellij attach {session_name}"
+    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

@@ -1,9 +1,8 @@
-
-
-from machineconfig.scripts.python.helpers_devops.cli_utils import download, merge_pdfs, get_machine_specs, init_project, compress_pdf
+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, tui_env
+from machineconfig.scripts.python.helpers_utils.download import download
 import typer
-from typing import Annotated, Optional
-from pathlib import Path
+from typing import Annotated
 
 
 def kill_process(
@@ -21,41 +20,40 @@ def kill_process(
                         #    )
 
 
-def add_dev_packages(repo_dir: Annotated[Optional[str], typer.Option(..., "--repo-dir", "-r", help="Path to the repository root directory")] = None):
-    if repo_dir is None:
-        r_dir = Path.cwd()
-    else:
-        r_dir = Path(repo_dir).resolve()
-    if not r_dir.exists() or not r_dir.is_dir() or not (r_dir / "pyproject.toml").exists():
-        typer.echo(f"❌ The provided repo directory `{r_dir}` is not valid or does not contain a `pyproject.toml` file.")
-        raise typer.Exit(code=1)
-    command = f"""
-cd "{r_dir}" || exit 1
-uv add nbformat ipdb ipykernel ipython pylint pyright mypy pyrefly ty pytest
-"""
-    from machineconfig.utils.code import run_shell_script
-    typer.echo(f"➡️  Installing dev packages in repo at `{r_dir}`...")
-    run_shell_script(command)
-    typer.echo(f"✅ Dev packages installed successfully in repo at `{r_dir}`.")
-    # TODO: see upgrade packages.
-
+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="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(name="download", no_args_is_help=True, help="[d] Download a file from a URL and optionally decompress it.")(download)
+
+    app.command("environment", no_args_is_help=False, help="📚 [v] NAVIGATE ENV/PATH variable with TUI")(tui_env)
+    app.command("v", no_args_is_help=False, help="NAVIGATE ENV/PATH variable with TUI", hidden=True)(tui_env)
+
+    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="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="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="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="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():
@@ -63,4 +61,4 @@ def get_app() -> typer.Typer:
 
 def main():
     app = get_app()
-    app()
+    app()

machineconfig/scripts/windows/mounts/mount_ssh.ps1

@@ -7,7 +7,7 @@ $user = ''
 $sharePath = ''
 $driveLetter = ''
 
-uv run --python 3.14 --with "machineconfig>=6.81" python -m machineconfig.scripts.python.mount_ssh
+uv run --python 3.14 --with "machineconfig>=7.98" 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/wrap_mcfg.ps1

@@ -0,0 +1,63 @@
+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."
+            Write-Host " "
+        }
+        & $env:OP_PROGRAM_PATH
+        # Write-Host "✅ '$Command' execution completed."
+
+    } else {
+        # Write-Host "✅ '$Command' execution completed."
+        Write-Host " "
+    }
+
+    # 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/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)"

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

@@ -20,8 +20,9 @@ case "$file" in
     echo "x: $x, y: $y, width: $width, height: $height"
     
     if [ -n "$x" ]; then
-        echo "📐 Dimensions provided by caller, passing to viu"
-        viu "$file" -x "$x" -y "$y" -w "$width" -h "$height"
+        # echo "📐 Dimensions provided by caller, passing to viu"
+        # viu "$file" -x "$x" -y "$y" -w "$width" -h "$height"
+        # chafa --fit-width -f sixel "$file"
         echo "✅ Finished viu"
         chafa "$file"
         echo "✅ Finished chafa"

machineconfig/settings/lf/windows/lfcd.ps1

@@ -17,7 +17,7 @@
 
 function lfcd {
     $tmp = [System.IO.Path]::GetTempFileName()
-    ~\AppData\Local\Microsoft\WindowsApps\lf.exe -last-dir-path="$tmp" $args
+    & "$env:USERPROFILE\AppData\Local\Microsoft\WindowsApps\lf.exe" -last-dir-path="$tmp" $args
     if (Test-Path -PathType Leaf "$tmp")
     {
         $dir = Get-Content "$tmp"

machineconfig/settings/lf/windows/lfrc

@@ -51,19 +51,19 @@ map x
 map c
 map v
 map r
-map D $diskonaut $env:f
-map K $kondo $env:f
+map D $diskonaut $f
+map K $kondo $f
 map r reload
 
 
 # e edit
 map e  # edit modal key.
-map en $nano $env:f
-map el $pwsh -File $env:USERPROFILE/.local/bin/lvim.ps1 -- $env:f
-map ev $nvim $env:f
-map ec $code $env:f
+map en $nano $f
+map el $pwsh -File $env:USERPROFILE/.local/bin/lvim.ps1 -- $f
+map ev $nvim $f
+map ec $code $f
 map ep $& 'C:\Program Files (x86)\JetBrains\PyCharm Community Edition 2022.2\bin\pycharm.exe' $f
-map o  $start $env:f
+map o  $start $f
 map <enter> open
 
 
@@ -73,27 +73,25 @@ map ww $powershell
 map wp $pwsh
 map wc $croshell.ps1
 map wm $cmd
-map i $~/.config/machineconfig/settings/lf/windows/previewer.ps1 $env:f
-map R $powershell $env:USERPROFILE/scripts/croshell.ps1 -r $env:f
+map i $~/.config/machineconfig/settings/lf/windows/previewer.ps1 $f
+map R $powershell $env:USERPROFILE/scripts/croshell.ps1 -r $f
 
 # o file/folder Operations
 map o
 map od cut
 map op paste
 map oy copy
-map oc $Set-Clipboard -Value $env:f
+map oc $Set-Clipboard -Value $f
 map c clear
 map or rename
-map <delete> :{{
-	delete
-	echo 'FINISHED DELETEING'
-}}
+map <delete> delete
+map <del> delete
 map of reload
 map os mark-save
 map ol mark-load
 map oR mark-remove
-map oD !ouch d $env:f
-map oC !ouch c $env:f '$env:f'.zip
+map oD !ouch d $f
+map oC !ouch c $f '$f'.zip
 
 # j jump
 map j