haoshoku 2.0.0

package/src/os_scripts/cachyos.js

@@ -0,0 +1,342 @@
+import { log, runCommand, commandExists } from "../common/utils.js";
+import prompts from "prompts";
+import path from "path";
+import fs from "fs";
+import { homedir } from "os";
+
+// --- Constants ---
+const HOME = homedir();
+const CARGO_HOME = path.join(HOME, ".cargo");
+const PARU_BUILD_DIR = "/tmp/paru";
+const STARSHIP_CONFIG_PATH = path.join(HOME, ".config", "starship.toml");
+const FISH_CONFIG_DIR = path.join(HOME, ".config", "fish");
+const PYENV_ROOT = path.join(HOME, ".pyenv");
+const GHOSTTY_CONFIG_DIR = path.join(HOME, ".config", "ghostty");
+const FASTFETCH_CONFIG_DIR = path.join(HOME, ".config", "fastfetch");
+const KITTY_CONFIG_DIR = path.join(HOME, ".config", "kitty");
+const ALACRITTY_CONFIG_DIR = path.join(HOME, ".config", "alacritty");
+
+// Project paths (assuming running from project root)
+const PROJECT_ROOT = process.cwd();
+const COMMON_DIR = path.join(PROJECT_ROOT, "common");
+const CONFIGS_DIR = path.join(PROJECT_ROOT, "configs");
+const HELPERS_DIR = path.join(PROJECT_ROOT, "helpers");
+
+const PARU_APPLIST_PATH = path.join(COMMON_DIR, "paru_applist.txt");
+const FLATPAK_APPLIST_PATH = path.join(COMMON_DIR, "flatpacks_arch.txt");
+const KDE_SHORTCUTS_PATH = path.join(CONFIGS_DIR, "kde_shortcuts.kksrc");
+const CUSTOM_FISH_CONFIG_PATH = path.join(CONFIGS_DIR, "fish", "config.fish");
+const CUSTOM_GHOSTTY_CONFIG_PATH = path.join(CONFIGS_DIR, "ghostty", "config");
+const CUSTOM_FASTFETCH_CONFIG_PATH = path.join(CONFIGS_DIR, "fastfetch", "config.jsonc");
+const CUSTOM_KITTY_CONFIG_PATH = path.join(CONFIGS_DIR, "kitty", "kitty.conf");
+const CUSTOM_ALACRITTY_CONFIG_PATH = path.join(CONFIGS_DIR, "alacritty", "alacritty.toml");
+
+// URLs
+const RUSTUP_URL = "https://sh.rustup.rs";
+const PARU_AUR_URL = "https://aur.archlinux.org/paru.git";
+const UV_INSTALL_URL = "https://astral.sh/uv/install.sh";
+const FOUNDRY_INSTALL_URL = "https://foundry.paradigm.xyz";
+const UOSC_INSTALL_URL = "https://raw.githubusercontent.com/tomasklaen/uosc/HEAD/installers/unix.sh";
+
+// --- Helper Functions ---
+
+async function promptUser(message, initial = false) {
+  const response = await prompts({
+    type: "confirm",
+    name: "value",
+    message: message,
+    initial: initial,
+  });
+  return response.value;
+}
+
+async function refreshSudo() {
+  log.info("Checking sudo access. You may be prompted for your password.");
+  return await runCommand("sudo -v");
+}
+
+async function installPackagesFromFile(filePath, installerCmd) {
+  if (!fs.existsSync(filePath)) {
+    log.warning(`Package file not found at ${filePath}`);
+    return;
+  }
+
+  const content = fs.readFileSync(filePath, "utf-8");
+  const packages = content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#"));
+
+  if (packages.length > 0) {
+    log.info(`Installing ${packages.length} packages...`);
+    await runCommand(`${installerCmd} ${packages.join(" ")}`);
+  }
+}
+
+// --- Installation Functions ---
+
+async function installBaseDependencies() {
+    log.info("Refreshing keyrings...");
+    // // Initialize and populate keys first to ensure we can verify signatures
+    // await runCommand("sudo pacman-key --init");
+    // await runCommand("sudo pacman-key --populate archlinux cachyos");
+    // // Then update the keyring packages
+    // await runCommand("sudo pacman -Sy --noconfirm archlinux-keyring cachyos-keyring");
+
+  log.info("Updating system and installing base-devel...");
+    //   await runCommand("sudo pacman -Syu base-devel --noconfirm");
+
+  log.info("Installing Rust via rustup...");
+  await runCommand(`curl ${RUSTUP_URL} -sSf | sh -s -- -y`);
+  
+    if (await commandExists("pyenv") && await commandExists("fish")) {
+    log.info("Configuring Pyenv for Fish...");
+        await runCommand(`fish -c 'set -Ux PYENV_ROOT "${PYENV_ROOT}"'`);
+        // Use set -U fish_user_paths as it is more robust than fish_add_path in some environments
+        await runCommand(`fish -c 'if not contains "${PYENV_ROOT}/bin" $fish_user_paths; set -Ua fish_user_paths "${PYENV_ROOT}/bin"; end'`);
+  }
+}
+
+async function installAurHelper() {
+  if (await commandExists("paru")) {
+    log.info("Paru is already installed.");
+    return;
+  }
+  log.info("Installing paru...");
+  await runCommand(
+    `git clone ${PARU_AUR_URL} ${PARU_BUILD_DIR} && cd ${PARU_BUILD_DIR} && makepkg -si --noconfirm`
+  );
+}
+
+async function installDevTools() {
+  if (!(await commandExists("uv"))) {
+    log.info("Installing uv...");
+    await runCommand(`curl -LsSf ${UV_INSTALL_URL} | sh`);
+  } else {
+    log.info("uv already installed.");
+  }
+
+  if (!(await commandExists("foundryup"))) {
+    log.info("Installing Foundry...");
+    await runCommand(`curl -L ${FOUNDRY_INSTALL_URL} | bash`);
+  } else {
+    log.info("Foundry (foundryup) already installed.");
+  }
+}
+
+async function setupFlatpakRemotes() {
+  if (await commandExists("flatpak")) {
+    log.info("Setting up Flatpak remotes...");
+    await runCommand(
+      "flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo"
+    );
+  } else {
+    log.warning("Flatpak not found. Skipping remote setup.");
+  }
+}
+
+// --- Configuration Functions ---
+
+async function configureFishShell() {
+  if (!(await commandExists("fish"))) {
+    log.info("Installing Fish shell...");
+    await runCommand("paru -S fish --noconfirm");
+  }
+
+  if (await promptUser("Set Fish as the default shell?", true)) {
+    const fishPathProc = Bun.spawn(["which", "fish"]);
+    const fishPath = (await new Response(fishPathProc.stdout).text()).trim();
+    
+    if (fishPath) {
+      log.info("Setting Fish as the default shell...");
+      await runCommand(`chsh -s ${fishPath}`);
+    } else {
+      log.warning("Could not find fish executable.");
+    }
+  }
+
+  log.info("Installing Fisher and plugins...");
+  const fisherPlugins = [
+    "jorgebucaran/fisher",
+    "meaningful-ooo/sponge",
+    "jorgebucaran/nvm.fish",
+    "franciscolourenco/done",
+    "joseluisq/gitnow@2.12.0",
+  ];
+  
+  for (const plugin of fisherPlugins) {
+    await runCommand(`fish -c "fisher install ${plugin}"`);
+  }
+
+  if (await commandExists("starship")) {
+    log.info("Configuring Starship prompt...");
+    await runCommand(`starship preset nerd-font-symbols -o ${STARSHIP_CONFIG_PATH}`);
+  }
+
+  fs.mkdirSync(FISH_CONFIG_DIR, { recursive: true });
+  if (fs.existsSync(CUSTOM_FISH_CONFIG_PATH)) {
+    fs.copyFileSync(CUSTOM_FISH_CONFIG_PATH, path.join(FISH_CONFIG_DIR, "config.fish"));
+    log.info("Copied custom fish config.");
+  }
+}
+
+async function configureTerminals() {
+  log.info("Configuring Kitty terminal...");
+  fs.mkdirSync(KITTY_CONFIG_DIR, { recursive: true });
+  if (fs.existsSync(CUSTOM_KITTY_CONFIG_PATH)) {
+    fs.copyFileSync(CUSTOM_KITTY_CONFIG_PATH, path.join(KITTY_CONFIG_DIR, "kitty.conf"));
+    log.info("Copied custom Kitty config.");
+  } else {
+    log.warning(`Custom Kitty config not found at ${CUSTOM_KITTY_CONFIG_PATH}`);
+  }
+
+  log.info("Configuring Alacritty terminal...");
+  fs.mkdirSync(ALACRITTY_CONFIG_DIR, { recursive: true });
+  if (fs.existsSync(CUSTOM_ALACRITTY_CONFIG_PATH)) {
+    fs.copyFileSync(CUSTOM_ALACRITTY_CONFIG_PATH, path.join(ALACRITTY_CONFIG_DIR, "alacritty.toml"));
+    log.info("Copied custom Alacritty config.");
+  } else {
+    log.warning(`Custom Alacritty config not found at ${CUSTOM_ALACRITTY_CONFIG_PATH}`);
+  }
+
+  log.info("Configuring Ghostty terminal...");
+  fs.mkdirSync(GHOSTTY_CONFIG_DIR, { recursive: true });
+  if (fs.existsSync(CUSTOM_GHOSTTY_CONFIG_PATH)) {
+    fs.copyFileSync(CUSTOM_GHOSTTY_CONFIG_PATH, path.join(GHOSTTY_CONFIG_DIR, "config"));
+    log.info("Copied custom Ghostty config.");
+  }
+}
+
+async function enableServices() {
+  if (await promptUser("Enable Bluetooth?", false)) {
+    log.info("Enabling Bluetooth service...");
+    await runCommand("sudo systemctl enable --now bluetooth");
+  }
+
+  if ((await commandExists("docker")) && (await promptUser("Enable Docker?", true))) {
+    log.info("Enabling and starting Docker service...");
+    await runCommand("sudo systemctl enable --now docker");
+    const user = process.env.USER;
+    if (user) {
+      await runCommand(`sudo usermod -aG docker ${user}`);
+      log.warning(`User ${user} added to docker group. Please log out and back in.`);
+    }
+  }
+}
+
+async function configureFastfetch() {
+  if (!(await commandExists("fastfetch"))) {
+    log.warning("Fastfetch command not found. Skipping configuration.");
+    return;
+  }
+
+  log.info("Configuring Fastfetch...");
+  fs.mkdirSync(FASTFETCH_CONFIG_DIR, { recursive: true });
+  if (fs.existsSync(CUSTOM_FASTFETCH_CONFIG_PATH)) {
+    fs.copyFileSync(CUSTOM_FASTFETCH_CONFIG_PATH, path.join(FASTFETCH_CONFIG_DIR, "config.jsonc"));
+    log.info("Fastfetch user config updated.");
+  } else {
+    log.warning(`Custom Fastfetch config not found at ${CUSTOM_FASTFETCH_CONFIG_PATH}`);
+  }
+}
+
+async function configureKde() {
+  if (await promptUser("Apply custom KDE Shortcuts?", false)) {
+    log.info("Applying custom KDE shortcuts...");
+    if (fs.existsSync(KDE_SHORTCUTS_PATH)) {
+      const kglobalshortcutsrc = path.join(HOME, ".config", "kglobalshortcutsrc");
+      if (fs.existsSync(kglobalshortcutsrc)) {
+        fs.copyFileSync(kglobalshortcutsrc, kglobalshortcutsrc + ".bak");
+        log.info(`Backed up existing shortcuts to ${kglobalshortcutsrc}.bak`);
+      }
+      fs.copyFileSync(KDE_SHORTCUTS_PATH, kglobalshortcutsrc);
+      log.info("KDE shortcuts applied. Please log out and log back in.");
+    } else {
+      log.warning(`KDE shortcuts file not found at ${KDE_SHORTCUTS_PATH}`);
+    }
+  }
+
+  log.info("Applying KDE Connect fix...");
+  await runCommand("sudo iptables -I INPUT -p tcp --dport 1714:1764 -j ACCEPT");
+  await runCommand("sudo iptables -I INPUT -p udp --dport 1714:1764 -j ACCEPT");
+  if (await commandExists("ufw")) {
+    await runCommand("sudo ufw allow 1714:1764/udp");
+    await runCommand("sudo ufw allow 1714:1764/tcp");
+    await runCommand("sudo ufw reload");
+  }
+
+  if (await promptUser("Install KDE Force Blur effect (requires build)?", false)) {
+    log.info("Installing prerequisites for KDE Force Blur...");
+    await runCommand("paru -S base-devel git extra-cmake-modules qt6-tools --noconfirm");
+    log.info("Cloning and building KDE Force Blur...");
+    await runCommand(
+      "cd /tmp && " +
+        "git clone https://github.com/taj-ny/kwin-effects-forceblur && " +
+        "cd kwin-effects-forceblur && " +
+        "mkdir build && cd build && " +
+        "cmake ../ -DCMAKE_INSTALL_PREFIX=/usr && " +
+        "make && sudo make install"
+    );
+  }
+}
+
+async function installSystemPackages() {
+  log.info("Preparing for package installation...");
+  if (!(await refreshSudo())) {
+    log.error("Sudo authentication failed. Skipping sudo-dependent installations.");
+    return;
+  }
+
+  log.info("Installing packages from file lists...");
+    //   await installPackagesFromFile(
+    //     PARU_APPLIST_PATH,
+    //     "paru -S --noconfirm --sudoloop --batchinstall"
+    //   );
+
+  log.info("Installing Nerd Fonts...");
+    //   await runCommand("sudo pacman -S $(pacman -Sgq nerd-fonts) --noconfirm");
+
+  if (await promptUser("Enable gaming configuration?", false)) {
+      // await runCommand(
+      //   "paru -S cachyos-gaming-meta cachyos-gaming-applications protonup-rs-bin --noconfirm"
+      // );
+  }
+}
+
+async function installFlatpakApps() {
+  await setupFlatpakRemotes();
+  await installPackagesFromFile(
+    FLATPAK_APPLIST_PATH,
+    "flatpak install --user -y flathub"
+  );
+}
+
+async function configureUserApps() {
+  await configureFishShell();
+
+  if (await promptUser("Configure git?", true)) {
+    const { configureGit } = await import("../helpers/configure_git.js");
+    await configureGit();
+  }
+
+  await configureTerminals();
+  await configureKde();
+
+  log.info("Installing uosc for MPV...");
+  await runCommand(`curl -fsSL ${UOSC_INSTALL_URL} | bash`);
+
+  await enableServices();
+  await configureFastfetch();
+}
+
+export async function runCachyOSSetup() {
+  await installBaseDependencies();
+  await installAurHelper();
+  await installDevTools();
+
+  await installSystemPackages();
+  await installFlatpakApps();
+  await configureUserApps();
+
+  log.success("CachyOS setup finished. Please restart your terminal or log out.");
+}

package/src/os_scripts/debian_server.js

@@ -0,0 +1,146 @@
+import { log, runCommand, commandExists } from "../common/utils.js";
+import prompts from "prompts";
+import path from "path";
+import fs from "fs";
+import { homedir } from "os";
+
+// --- Constants ---
+const HOME = homedir();
+const FISH_CONFIG_DIR = path.join(HOME, ".config", "fish");
+const STARSHIP_CONFIG_PATH = path.join(HOME, ".config", "starship.toml");
+
+// Project paths
+const PROJECT_ROOT = process.cwd();
+const CONFIGS_DIR = path.join(PROJECT_ROOT, "configs");
+const CUSTOM_FISH_CONFIG_PATH = path.join(CONFIGS_DIR, "fish", "config.fish");
+
+// --- Helper Functions ---
+
+async function promptUser(message, initial = false) {
+  const response = await prompts({
+    type: "confirm",
+    name: "value",
+    message: message,
+    initial: initial,
+  });
+  return response.value;
+}
+
+async function installEssentials() {
+  log.info("Updating system and installing essentials...");
+  await runCommand("sudo apt update && sudo apt upgrade -y");
+  await runCommand("sudo apt install -y curl wget git vim ufw fail2ban software-properties-common");
+}
+
+async function setupSsh() {
+  log.info("Setting up SSH...");
+  // User requested NOT to disable SSH login, so we just ensure keys are added.
+  const sshDir = path.join(HOME, ".ssh");
+  if (!fs.existsSync(sshDir)) {
+    fs.mkdirSync(sshDir, { mode: 0o700 });
+  }
+
+  const authorizedKeysPath = path.join(sshDir, "authorized_keys");
+  if (!fs.existsSync(authorizedKeysPath)) {
+    fs.writeFileSync(authorizedKeysPath, "", { mode: 0o600 });
+  }
+
+  // We could prompt to add a key here, or just leave it for manual addition.
+  // For now, we'll just ensure the service is enabled.
+  await runCommand("sudo systemctl enable ssh");
+  await runCommand("sudo systemctl start ssh");
+  
+  log.info("SSH setup complete. Remember to add your public key to ~/.ssh/authorized_keys");
+}
+
+async function configureFishShell() {
+  if (!(await commandExists("fish"))) {
+    log.info("Installing Fish shell...");
+    await runCommand("sudo apt-add-repository -y ppa:fish-shell/release-3");
+    await runCommand("sudo apt update");
+    await runCommand("sudo apt install -y fish");
+  }
+
+  if (await promptUser("Set Fish as the default shell?", true)) {
+    const fishPathProc = Bun.spawn(["which", "fish"]);
+    const fishPath = (await new Response(fishPathProc.stdout).text()).trim();
+    
+    if (fishPath) {
+      log.info("Setting Fish as the default shell...");
+      await runCommand(`sudo chsh -s ${fishPath} ${process.env.USER}`);
+    } else {
+      log.warning("Could not find fish executable.");
+    }
+  }
+
+  log.info("Installing Fisher and plugins...");
+  // Ensure fish config dir exists
+  fs.mkdirSync(FISH_CONFIG_DIR, { recursive: true });
+
+  const fisherPlugins = [
+    "jorgebucaran/fisher",
+    "meaningful-ooo/sponge",
+    "jorgebucaran/nvm.fish",
+    "franciscolourenco/done",
+    "joseluisq/gitnow@2.12.0",
+  ];
+  
+  for (const plugin of fisherPlugins) {
+    await runCommand(`fish -c "fisher install ${plugin}"`);
+  }
+
+  // Starship
+  if (!(await commandExists("starship"))) {
+    log.info("Installing Starship...");
+    await runCommand("curl -sS https://starship.rs/install.sh | sh -s -- -y");
+  }
+  
+  log.info("Configuring Starship prompt...");
+  await runCommand(`starship preset nerd-font-symbols -o ${STARSHIP_CONFIG_PATH}`);
+
+  if (fs.existsSync(CUSTOM_FISH_CONFIG_PATH)) {
+    fs.copyFileSync(CUSTOM_FISH_CONFIG_PATH, path.join(FISH_CONFIG_DIR, "config.fish"));
+    log.info("Copied custom fish config.");
+  }
+}
+
+async function installDocker() {
+  if (await promptUser("Install Docker?", true)) {
+    if (await commandExists("docker")) {
+      log.info("Docker already installed.");
+      return;
+    }
+    
+    log.info("Installing Docker...");
+    await runCommand("curl -fsSL https://get.docker.com | sh");
+    
+    const user = process.env.USER;
+    if (user) {
+      await runCommand(`sudo usermod -aG docker ${user}`);
+      log.warning(`User ${user} added to docker group.`);
+    }
+  }
+}
+
+async function setupFirewall() {
+  log.info("Setting up UFW...");
+  await runCommand("sudo ufw default deny incoming");
+  await runCommand("sudo ufw default allow outgoing");
+  await runCommand("sudo ufw allow ssh");
+  await runCommand("sudo ufw allow http");
+  await runCommand("sudo ufw allow https");
+  
+  if (await promptUser("Enable UFW now?", true)) {
+    await runCommand("sudo ufw enable");
+  }
+}
+
+export async function runDebianServerSetup() {
+  await installEssentials();
+  await setupSsh();
+  await configureFishShell();
+  await installDocker();
+  await setupFirewall();
+
+  log.success("Debian Server setup finished.");
+}

package/tests/test_cachyos.py

@@ -0,0 +1,37 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+import sys
+
+# Add project root to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from os_scripts.cachyos import command_exists, install_packages_from_file
+
+def test_command_exists():
+    """Test checking for command existence."""
+    with patch('shutil.which') as mock_which:
+        mock_which.return_value = "/usr/bin/git"
+        assert command_exists("git") is True
+        
+        mock_which.return_value = None
+        assert command_exists("nonexistentcommand") is False
+
+@patch('os_scripts.cachyos.run_command')
+@patch('pathlib.Path.is_file')
+@patch('pathlib.Path.read_text')
+def test_install_packages_from_file(mock_read, mock_is_file, mock_run):
+    """Test reading packages from file and installing them."""
+    mock_is_file.return_value = True
+    mock_read.return_value = "package1\npackage2\n#comment\n\npackage3"
+    
+    install_packages_from_file("dummy_path", "pacman -S")
+    
+    # Verify the command was called with the correct packages
+    # Should include package1, package2, package3, ignoring comments and empty lines
+    args = mock_run.call_args[0][0]
+    assert "package1" in args
+    assert "package2" in args
+    assert "package3" in args
+    assert "pacman -S" in args
+

package/tests/test_common.py

@@ -0,0 +1,73 @@
+import pytest
+from pathlib import Path
+import sys
+
+# Add project root to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+def test_common_directory_structure():
+    """Test that the common directory exists and has required files."""
+    # When running tests locally
+    root_dir = Path(__file__).parent.parent
+    common_dir = root_dir / "common"
+    
+    assert common_dir.exists(), "common directory must exist"
+    assert common_dir.is_dir(), "common must be a directory"
+    
+    required_files = [
+        "paru_applist.txt",
+        "flatpacks_arch.txt",
+        "apt_applist.txt",
+        "dnf_applist.txt",
+        "flatpacks.txt",
+        "snap_applist.txt",
+        "__init__.py"
+    ]
+    
+    for filename in required_files:
+        file_path = common_dir / filename
+        assert file_path.exists(), f"{filename} must exist in common directory"
+        assert file_path.is_file(), f"{filename} must be a file"
+
+def test_common_files_content():
+    """Test that common files are not empty and have valid content."""
+    root_dir = Path(__file__).parent.parent
+    common_dir = root_dir / "common"
+    
+    # Test package list files
+    package_lists = [
+        "paru_applist.txt",
+        "flatpacks_arch.txt",
+        "apt_applist.txt",
+        "dnf_applist.txt",
+        "flatpacks.txt",
+        "snap_applist.txt"
+    ]
+    
+    for filename in package_lists:
+        file_path = common_dir / filename
+        content = file_path.read_text().strip()
+        
+        # Check file is not empty (unless it's intended to be empty, but usually these shouldn't be)
+        assert len(content) > 0, f"{filename} should not be empty"
+        
+        # Check content format - lines should not start with whitespace
+        lines = content.splitlines()
+        for i, line in enumerate(lines):
+            if line.strip() and not line.startswith('#'):
+                assert not line.startswith(' '), f"Line {i+1} in {filename} has leading whitespace"
+
+def test_package_data_access():
+    """Test that we can access these files via package resources (simulating installed package)."""
+    # This test simulates how the code would access files when installed
+    # Note: This depends on the package being installed or editable install, 
+    # but we can check if the mechanism works relative to the package root
+    
+    try:
+        import common
+        common_path = Path(common.__file__).parent
+        assert common_path.exists()
+        assert (common_path / "paru_applist.txt").exists()
+    except ImportError:
+        pytest.skip("common package not importable - skipping package access test")
+

package/tests/test_kde_config.py

@@ -0,0 +1,69 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+import shutil
+import sys
+
+# Add project root to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+# Manually define KDE_SHORTCUTS_PATH for testing purposes if import fails,
+# or better, mock it entirely since we're patching it anyway.
+# The ImportError happens because os_scripts/cachyos.py relies on project structure 
+# that might look different in the test environment or due to circular imports?
+# Actually, let's just import the module and patch attributes.
+
+import os_scripts.cachyos as cachyos_module
+
+def test_configure_kde_shortcuts_apply(tmp_path):
+    """Test that KDE shortcuts are applied correctly."""
+    # Setup mock home directory
+    mock_home = tmp_path / "home"
+    mock_home.mkdir()
+    mock_config = mock_home / ".config"
+    mock_config.mkdir()
+    
+    # Create existing config file with some realistic content
+    existing_conf = mock_config / "kglobalshortcutsrc"
+    existing_conf.write_text("[General]\nTest=ExistingShortcut")
+    
+    # Mock KDE_SHORTCUTS_PATH to point to a real file
+    mock_shortcuts_file = tmp_path / "new_shortcuts.kksrc"
+    mock_shortcuts_file.write_text("[General]\nTest=NewShortcut")
+
+    with (
+        patch("os_scripts.cachyos.HOME", mock_home),
+        patch("os_scripts.cachyos.prompt_user", return_value=True),
+        patch("os_scripts.cachyos.KDE_SHORTCUTS_PATH", mock_shortcuts_file),
+        patch("os_scripts.cachyos.run_command"),
+    ):
+
+        cachyos_module.configure_kde()
+        
+        # Check if backup was created
+        backup_file = existing_conf.with_suffix(".bak")
+        assert backup_file.exists()
+        assert backup_file.read_text() == "[General]\nTest=ExistingShortcut"
+        
+        # Check if new content was copied
+        assert existing_conf.read_text() == "[General]\nTest=NewShortcut"
+
+def test_configure_kde_shortcuts_skip():
+    """Test that shortcuts are skipped when user says no."""
+    with patch('os_scripts.cachyos.prompt_user', return_value=False), \
+         patch('os_scripts.cachyos.run_command'):
+        
+        # Should run without errors and not attempt any file operations
+        cachyos_module.configure_kde()
+
+def test_configure_kde_shortcuts_missing_file(tmp_path):
+    """Test handling when source shortcut file is missing."""
+    # Mock KDE_SHORTCUTS_PATH to non-existent file
+    non_existent = tmp_path / "does_not_exist"
+    
+    with patch('os_scripts.cachyos.prompt_user', return_value=True), \
+         patch('os_scripts.cachyos.KDE_SHORTCUTS_PATH', non_existent), \
+         patch('os_scripts.cachyos.run_command'):
+        
+        # Should log warning but not fail
+        cachyos_module.configure_kde()