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

machineconfig/scripts/python/sessions.py

@@ -1,33 +1,56 @@
 
-from pathlib import Path
-from typing import Optional, Literal
+from typing import Optional, Literal, Annotated
 import typer
 
 
-def balance_load(layout_path: Path = typer.Argument(..., help="Path to the layout.json file"),
-           max_thresh: int = typer.Option(..., help="Maximum tabs per layout"),
-           thresh_type: Literal['number', 'weight'] = typer.Option(..., help="Threshold type"),
-           breaking_method: Literal['moreLayouts', 'combineTabs'] = typer.Option(..., help="Breaking method"),
-           output_path: Optional[Path] = typer.Option(None, help="Path to write the adjusted layout.json file")):
+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 LayoutConfig, LayoutsFile
-    layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
+    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
+    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
@@ -35,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] = []
@@ -50,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.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
-
-
-def launch(ctx: typer.Context,
-           layout_path: Optional[str] = typer.Argument(None, help="Path to the layout.json file"),
-        max_tabs: int = typer.Option(10, help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch."),
-        max_layouts: int = typer.Option(10, help="A Sanity checker that throws an error if the total number of layouts exceeds this number."),
-        sleep_inbetween: float = typer.Option(1.0, help="Sleep time in seconds between launching layouts"),
-        monitor: bool = typer.Option(False, "--monitor", "-m", help="Monitor the layout sessions for completion"),
-        parallel: bool = typer.Option(False, "--parallel", "-p", help="Launch multiple layouts in parallel"),
-        kill_upon_completion: bool = typer.Option(False, "--kill-upon-completion", "-k", help="Kill session(s) upon completion (only relevant if monitor flag is set)"),
-        choose: Optional[str] = typer.Option(None, "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed"),
-        choose_interactively: bool = typer.Option(False, "--choose-interactively", "-ia", help="Select layouts interactively")
+    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,
+        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.
@@ -87,10 +111,10 @@ def launch(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 len(layouts_selected) > max_layouts:
+    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:
@@ -99,7 +123,6 @@ def launch(ctx: typer.Context,
             if not confirm:
                 typer.echo("Aborting launch.")
                 raise typer.Exit(0)
-
     import time
     import platform
     if platform.system() == "Linux" or platform.system() == "Darwin":
@@ -132,15 +155,66 @@ def launch(ctx: typer.Context,
         print(f"❌ Unsupported platform: {platform.system()}")
 
 
-def main_from_parser():
-    layouts_app = typer.Typer(help="Layouts management subcommands")
-    layouts_app.command("run")(launch)
-    layouts_app.command("balance-load")(balance_load)
-    import sys
-    if len(sys.argv) == 1:
-        layouts_app(["--help"])
+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:
-        layouts_app()
+        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
+
+
+def main():
+    layouts_app = get_app()
+    layouts_app()
 
 
 if __name__ == "__main__":

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

@@ -0,0 +1,64 @@
+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
+
+
+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("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="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.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/{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,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/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