feat: add home manager package TUI script

.gitignore

@@ -1,2 +1,3 @@
 .direnv/
 .DS_Store
+*__pycache__

modules/ocf/graphical.nix

@@ -214,13 +214,16 @@ in
       };
     };
 
-    systemd.user.services.desktoprc = {
-      description = "Source custom rc shared across desktops";
-      after = [ "graphical-session.target" ];
-      partOf = [ "graphical-session.target" ];
+    systemd.user.services.home-manager = {
+      description = "Load custom home manager config if present";
+      # Only load when in a graphical session as SSHFS only mounts during graphical login
       wantedBy = [ "graphical-session.target" ];
+      path = [ pkgs.nix pkgs.git ];
       script = ''
-        [ -f ~/remote/.desktoprc ] && . ~/remote/.desktoprc
+        # Will create a template directory if it doesn't exist. Maybe look into creating
+        # our own template repo as currently users will need to edit nix files to get 
+        # custom packages etc...
+        nix run home-manager -- init --switch ~/remote/.home-manager
       '';
     };
 

pkgs/add-nix-package.nix

@@ -0,0 +1,21 @@
+{ python3Packages}:
+
+python3Packages.buildPythonApplication {
+  pname = "add-nix-package";
+  version = "2025-2-3";
+  format = "other";
+
+  dontUnpack = true;
+
+  installPhase = ''
+    cp ${./add-nix-package} $out/bin/add-nix-package
+  '';
+
+  propagatedBuildInputs = [
+    textual
+  ];
+
+  meta = {
+    description = "OCF NixOS script for adding packages to a home manager file";
+  };
+}

pkgs/add-nix-package/add-nix-package.py

@@ -0,0 +1,133 @@
+from textual.app import App, ComposeResult
+from textual.containers import Container
+from textual.widgets import Input, Button, Label, ListView, ListItem, Log, Static
+from textual.binding import Binding
+import json
+import subprocess
+import os
+from write_to_hm import *
+
+#TODO Allow unfree packages?
+
+AUTO_HM_FILEPATH = "~/.remote/auto-pkgs.nix"
+HM_FILEPATH = "~/.remote/.home-manager.nix"
+
+class LabelItem(ListItem):
+    def __init__(self, label):
+        super().__init__()
+        self.label = label
+
+    def compose(self) -> ComposeResult:
+        yield Label(self.label)
+
+class NixPackageSearchTUI(App):
+    pkg_list = []
+    if os.path.exists("styles.css"):
+        CSS_PATH = "styles.css"  # Optional: Add styles if needed
+
+    BINDINGS = [
+        Binding("enter", "handle_enter", "Search for the package or add to the list.", show=False, priority=True),
+        ("esc", "quit", "Quit the application"),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.nix_search_command = self.detect_nix_search_command()
+
+    def detect_nix_search_command(self) -> str:
+        """Detect the appropriate nix search command based on the OS."""
+        try:
+            if "Nix" in os.uname().version:
+                return "nix search"
+            else:
+                return "nix-search"
+        except AttributeError:
+            # Fallback if os.uname() is not available
+            return "nix-search"
+
+    def compose(self) -> ComposeResult:
+        """Define the TUI layout."""
+        yield Container(
+            Label("Nix Package Search", id="title"),
+            Input(placeholder="Enter package name...", id="package_input", restrict=r"[\w\-]*"),
+            ListView(id="results_list"),
+            Button("Add Selected Package to Home Manager", id="add_button"),
+            Log("Status", id="status"),
+        )
+
+
+    async def on_mount(self) -> None:
+        """Run actions when the app starts."""
+        self.query_one("#add_button").disabled = True  # Disable Add button initially
+        title = self.query_one('#title')
+        title.styles.background = "blue"
+        self.query_one('#results_list').styles.height = 10
+        self.log_widget = self.query_one('#status')
+
+    async def action_search(self) -> None:
+        """Handle the search action."""
+        package_input = self.query_one("#package_input").value.strip()
+        results_list = self.query_one("#results_list")
+        # self.screen.focus_next(selector='#results_list')
+
+        if not package_input:
+            return  # No input to search
+
+        self.log_widget.write_line("Searching packages...")
+
+        command = self.nix_search_command.split() + ["--max-results", "10", "--json", package_input]
+        output = subprocess.check_output(command).split(b'\n')
+        results_list.clear()
+
+        results = [json.loads(i) for i in output if i]
+        if results:
+            for pkg in results:
+                assert isinstance(pkg, dict)
+                package_name = pkg.get("package_pname", "Unknown")
+                package_desc = pkg.get("package_description", "No description available.")
+                display_text = f"{package_name}: {package_desc}"
+
+                # Add to ListView
+                results_list.append(LabelItem(display_text))
+
+                # Add to backend list
+                self.pkg_list.append(pkg["package_pname"])
+
+            self.query_one("#add_button").disabled = False
+            self.screen.focus_next(selector="#results_list")
+            results_list.children[0].focus()
+
+            self.log_widget.write_line("Packages found!")
+        else:
+            self.query_one("#add_button").disabled = True
+
+
+    async def action_add_selected(self) -> None:
+        """Handle adding a selected package."""
+        results_list = self.query_one("#results_list")
+        selected = results_list.highlighted_child
+        self.log(selected)
+
+        if selected is None:
+            raise Exception("nuh uh")  # No package selected
+
+        ensure_autohm_imports(HM_FILEPATH, AUTO_HM_FILEPATH)
+        ensure_autohm_file(AUTO_HM_FILEPATH)
+        self.log_widget.write_line(f"Writing package {selected.label.split(':')[0]} to {AUTO_HM_FILEPATH}")
+        write_status = add_package_to_autohm(AUTO_HM_FILEPATH, selected.label.split(":")[0])
+        if write_status:
+            self.log_widget.write_line(write_status)
+        results_list.clear()
+        self.log_widget.write_line("Done writing package.")
+
+    async def action_handle_enter(self) -> None:
+        "Handle enter key pressed"
+        if self.screen.focused == self.query_one('#results_list'):
+            await self.action_add_selected()
+        elif self.screen.focused == self.query_one('#package_input'):
+            await self.action_search()
+
+if __name__ == "__main__":
+    app = NixPackageSearchTUI()
+    app.run()
+    subprocess.check_output(["nix","run", "home-manager", "--", "--flake", "~/remote/.home-manager", "switch"])

pkgs/add-nix-package/write_to_hm.py

@@ -0,0 +1,152 @@
+import os
+import re
+
+def ensure_autohm_imports(hmfilepath: str, autohmpath: str) -> None:
+        hmpath = os.path.expanduser(hmfilepath)
+        relative_import_path = os.path.expanduser(f"./{autohmpath.split("/")[-1]}")
+
+        try:
+            # Read existing content
+            if os.path.exists(hmpath):
+                with open(hmpath, "r") as file:
+                    lines = file.readlines()
+            else:
+                lines = []
+
+            # Patterns to detect the `home-manager.users` block
+            user_block_pattern = re.compile(r"^\s*home-manager\.users\.[a-zA-Z0-9_-]+\s*=\s*\{")
+            imports_pattern = re.compile(r"^\s*imports\s*=\s*\[")
+            block_start_line = None
+            block_end_line = None
+            imports_line = None
+
+            # Step 1: Find the `home-manager.users` block
+            for i, line in enumerate(lines):
+                if user_block_pattern.search(line):  # Found the user block start
+                    block_start_line = i
+                elif block_start_line is not None and line.strip() == "};":  # Found the block end
+                    block_end_line = i
+                    break
+                elif block_start_line is not None and imports_pattern.search(line):  # Found imports line
+                    imports_line = i
+
+            if block_start_line is None or block_end_line is None:
+                return
+
+            users_block = lines[:]
+
+            # Step 2: Modify or add the imports block inside the user block
+            import_line = f"    {relative_import_path}\n"
+
+            if imports_line is not None:  # If an imports block already exists
+                # Check if autohmpath is already there
+                if import_line.strip() not in [l.strip() for l in lines[imports_line + 1 : block_end_line]]:
+                    users_block.insert(imports_line + 1, import_line)
+            else:  # No imports block found, create one before `};`
+                users_block.insert(block_start_line + 1, f"  imports = [\n{import_line}  ];\n")
+
+            # Step 3: Write back the modified file
+            with open(hmpath, "w") as file:
+                file.writelines(users_block)
+
+        except Exception as e:
+            print(f"Error modifying {hmfilepath}: {e}")
+
+def ensure_autohm_file(autohmpath: str) -> None:
+    """
+    Ensures that the autohmpath file exists. If it doesn't, creates it.
+
+    :param autohmpath: Path to the auto-home-manager Nix file.
+    """
+    autohmpath = os.path.expanduser(autohmpath)  # Expand ~ to home directory
+
+    if not os.path.exists(autohmpath):
+        try:
+            os.makedirs(os.path.dirname(autohmpath), exist_ok=True)  # Ensure parent directories exist
+
+            # Write default structure to file
+            with open(autohmpath, "w") as file:
+                file.write("""\
+{ pkgs, ... }:
+
+{
+  home.packages = [
+    # Packages generated using the config script will go here.
+  ];
+}
+""")
+            print(f"Created {autohmpath} with default content.")
+
+        except Exception as e:
+            print(f"Error creating {autohmpath}: {e}")
+    else:
+        return
+
+
+def add_package_to_autohm(autohmpath: str, pkgname: str) -> str:
+    """
+    Adds 'pkgs.pkgname' to the 'home.packages' block in autohmpath.
+    If 'home.packages' does not exist, it creates one.
+
+    :param autohmpath: Path to the auto_pkgs.nix file
+    :param pkgname: The package name to be added as pkgs.pkgname
+    :return Status message
+    """
+    autohmpath = os.path.expanduser(autohmpath)
+
+    status = ""
+
+    # Read the existing content
+    if os.path.exists(autohmpath):
+        with open(autohmpath, "r") as file:
+            lines = file.readlines()
+    else: # Make the file
+        lines = ["{ pkgs, ... }:\n", "\n", "{\n", "  home.packages = [\n", "  ];\n", "};\n"]
+
+    # Ensure home.packages block exists
+    in_packages_block = False
+    packages_start = None
+    packages_end = None
+
+    for i, line in enumerate(lines):
+        if re.search(r"^\s*home\.packages\s*=\s*\[", line):  # Start of block
+            in_packages_block = True
+            packages_start = i
+        elif in_packages_block and re.search(r"^\s*\];", line):  # End of block
+            packages_end = i
+            break
+
+    if packages_start is None or packages_end is None:
+        # If home.packages doesn't exist, create it before closing `};`
+        for i, line in enumerate(lines):
+            if line.strip() == "};":  # Insert before closing brace
+                lines.insert(i, "  home.packages = [\n  ];\n")
+                packages_start = i
+                packages_end = i + 1
+                break
+
+    # Define the package line
+    package_line = f"    pkgs.{pkgname}\n"
+
+    # Check if package already exists
+    existing_packages = [line.strip() for line in lines[packages_start + 1 : packages_end]]
+
+    if package_line.strip() not in existing_packages:
+        # Insert before the closing bracket of home.packages
+        lines.insert(packages_end, package_line)
+    else:
+        status = "Package already in file."
+
+    # Write back to the file
+    with open(autohmpath, "w") as file:
+        file.writelines(lines)
+
+    return status
+
+
+if __name__ == "__main__":
+    HMPATH = "~/.remote/home-manager.nix"
+    AUTO_HM_FILEPATH = "~/.remote/auto-pkgs.nix"
+    ensure_autohm_imports(HMPATH, AUTO_HM_FILEPATH)
+    ensure_autohm_file(AUTO_HM_FILEPATH)
+    add_package_to_autohm(AUTO_HM_FILEPATH, "test2")