`23d0de2`

extend group functionality

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 11 months ago

SHA: 23d0de20878dbd5724098e7f0454dce33ec7baea
Parents: cceeb7c
Tree: 5bf7284

5 changed files

Status	File	+	-
M	`src/shtick/cli.py`	67	1
M	`src/shtick/commands.py`	168	55
M	`src/shtick/config.py`	69	31
M	`src/shtick/security.py`	31	7
M	`src/shtick/shtick.py`	88	0

src/shtick/cli.pymodified

          help="Show one shell per line instead of columns",
+     )
++    # Add group management commands
++    group_parser = subparsers.add_parser("group", help="Group management commands")
++    group_subparsers = group_parser.add_subparsers(
++        dest="group_command", help="Group commands"
++    )
++
++    # Create group
++    create_parser = group_subparsers.add_parser("create", help="Create a new group")
++    create_parser.add_argument("name", help="Group name")
++    create_parser.add_argument("-d", "--description", help="Group description")
++
++    # Remove group
++    remove_parser = group_subparsers.add_parser("remove", help="Remove a group")
++    remove_parser.add_argument("name", help="Group name")
++    remove_parser.add_argument(
++        "-f", "--force", action="store_true", help="Force removal without confirmation"
++    )
++
++    # Rename group
++    rename_parser = group_subparsers.add_parser("rename", help="Rename a group")
++    rename_parser.add_argument("old_name", help="Current group name")
++    rename_parser.add_argument("new_name", help="New group name")
++
++    # Backup commands
++    backup_parser = subparsers.add_parser("backup", help="Backup management commands")
++    backup_subparsers = backup_parser.add_subparsers(
++        dest="backup_command", help="Backup commands"
++    )
++
++    # Create backup
++    backup_create_parser = backup_subparsers.add_parser(
++        "create", help="Create a backup"
++    )
++    backup_create_parser.add_argument(
++        "-n", "--name", help="Backup name (timestamp used if not provided)"
++    )
++
++    # List backups
++    backup_list_parser = backup_subparsers.add_parser(
++        "list", help="List available backups"
++    )
++
++    # Restore backup
++    backup_restore_parser = backup_subparsers.add_parser(
++        "restore", help="Restore from backup"
++    )
++    backup_restore_parser.add_argument("name", help="Backup name or filename")
++
      # Source command (for eval)
      source_parser = subparsers.add_parser(
          "source", help="Output source command for eval (for immediate loading)"
                  commands.settings_set(args.key, args.value)
              else:
                  settings_parser.print_help()
++        elif args.command == "group":
++            if args.group_command == "create":
++                commands.group_create(args.name, args.description)
++            elif args.group_command == "rename":
++                commands.group_rename(args.old_name, args.new_name)
++            elif args.group_command == "remove":
++                commands.group_remove(args.name, args.force)
++            else:
++                group_parser.print_help()
++        elif args.command == "backup":
++            if args.backup_command == "create":
++                commands.backup_create(args.name)
++            elif args.backup_command == "list":
++                commands.backup_list()
++            elif args.backup_command == "restore":
++                commands.backup_restore(args.name)
++            else:
++                backup_parser.print_help()
      except KeyboardInterrupt:
          logger.debug("Operation cancelled by user")
          print("\nCancelled")
--        sys.exit(1)
++        sys.exit(2)  # Use exit code 2 for user cancellation
      except Exception as e:
          if args.debug:
              logger.exception("Unhandled exception")

src/shtick/commands.pymodified

  """
--Command implementations for shtick CLI - REFACTORED to use ShtickManager
++Command implementations for shtick CLI - FIXED WITH CONSISTENT RETURN STATUSES
  """
  import os
  class ShtickCommands:
--    """Central command handler for shtick operations - now using ShtickManager"""
++    """Central command handler for shtick operations - with consistent return codes"""
      def __init__(self, debug: bool = False):
          # Set up logging based on debug flag
          self.manager = ShtickManager(debug=debug)
++    def _exit_error(self, message: str, code: int = 1):
++        """Print error message and exit with given code"""
++        print(f"Error: {message}")
++        sys.exit(code)
++
++    def _exit_success(self, message: str = None, code: int = 0):
++        """Print optional success message and exit with code"""
++        if message:
++            print(message)
++        sys.exit(code)
++
      def get_current_shell(self) -> Optional[str]:
          """Use cached shell detection from Config"""
          return Config.get_current_shell()
              logger.error(f"Failed to create {primary_config}: {e}")
              return False
--    # Command implementations - now using ShtickManager
++    # Command implementations - now with consistent return statuses
      def generate(self, config_path: str = None, terse: bool = False):
          """Generate shell files from config"""
          try:
              if config_path:
--                # Validate path for security
++                # Validate path for security with relaxed rules for generate
--                validated_path = validate_config_path(config_path)
++                validated_path = validate_config_path(config_path, for_generate=True)
++
++                # Warn about custom config behavior
++                if not terse:
++                    print("Note: Generating from custom config file")
++                    print("This will overwrite files but won't affect active groups")
++
                  # Create a new manager with custom config path
                  manager = ShtickManager(config_path=validated_path)
              else:
                  manager = self.manager
              success = manager.generate_shell_files()
--            if success and not terse:
++            if success:
++                if not terse:
                      self.check_shell_integration()
--            elif not success:
++                self._exit_success()  # Explicit success
--                print("Error: Failed to generate shell files")
++            else:
--                sys.exit(1)
++                self._exit_error("Failed to generate shell files")
          except FileNotFoundError as e:
--            print(f"Error: {e}")
++            self._exit_error(f"{e}\nCreate a config file first")
--            print(f"Create a config file first")
--            sys.exit(1)
          except Exception as e:
--            print(f"Error: {e}")
++            self._exit_error(str(e))
--            sys.exit(1)
      def add_item(self, item_type: str, group: str, assignment: str):
          """Add an item to a specific group"""
          try:
              key, value = self.validate_assignment(assignment)
          except ValueError as e:
--            print(f"Error: {e}")
++            self._exit_error(str(e))
--            sys.exit(1)
          # Dispatch to appropriate manager method
          if item_type == "alias":
          elif item_type == "function":
              success = self.manager.add_function(key, value, group)
          else:
--            print(f"Error: Unknown item type '{item_type}'")
++            self._exit_error(f"Unknown item type '{item_type}'")
--            sys.exit(1)
          if success:
              print(f"✓ Added {item_type} '{key}' = '{value}' to group '{group}'")
                  and group in self.manager.get_active_groups()
              ):
                  self.offer_auto_source()
++            self._exit_success()  # Explicit success
          else:
--            print(f"Error: Failed to add {item_type}")
++            self._exit_error(f"Failed to add {item_type}")
--            sys.exit(1)
      def add_persistent(self, item_type: str, assignment: str):
          """Add an item to the persistent group"""
          try:
              key, value = self.validate_assignment(assignment)
          except ValueError as e:
--            print(f"Error: {e}")
++            self._exit_error(str(e))
--            sys.exit(1)
          is_first_time = not os.path.exists(Config.get_default_config_path())
          elif item_type == "function":
              success = self.manager.add_persistent_function(key, value)
          else:
--            print(f"Error: Unknown item type '{item_type}'")
++            self._exit_error(f"Unknown item type '{item_type}'")
--            sys.exit(1)
          if success:
              print(
              if is_first_time:
                  print("\n🎉 Welcome to shtick!")
                  self.check_shell_integration()
++
++            self._exit_success()  # Explicit success
          else:
--            print(f"Error: Failed to add {item_type}")
++            self._exit_error(f"Failed to add {item_type}")
--            sys.exit(1)
      def remove_item(self, item_type: str, group: str, search: str):
          """Remove an item from a group"""
                  print(
                      f"No {item_type} items matching '{search}' found in group '{group}'"
+                 )
--                return
++                self._exit_success()  # Not an error - nothing to remove
              # Handle single vs multiple matches
              item_to_remove = self._select_item_to_remove(matches)
              if not item_to_remove:
--                return
++                self._exit_success()  # User cancelled - not an error
              # Dispatch to appropriate manager method
              if item_type == "alias":
              elif item_type == "function":
                  success = self.manager.remove_function(item_to_remove, group)
              else:
--                print(f"Error: Unknown item type '{item_type}'")
++                self._exit_error(f"Unknown item type '{item_type}'")
--                return
              if success:
                  print(f"✓ Removed {item_type} '{item_to_remove}' from group '{group}'")
                  # Offer to source if group is active
                  if group == "persistent" or group in self.manager.get_active_groups():
                      self.offer_auto_source()
++                self._exit_success()  # Explicit success
              else:
--                print(f"Failed to remove {item_type} '{item_to_remove}'")
++                self._exit_error(f"Failed to remove {item_type} '{item_to_remove}'")
          except Exception as e:
--            print(f"Error: {e}")
++            self._exit_error(str(e))
--            sys.exit(1)
      def _select_item_to_remove(self, matches: List[str]) -> Optional[str]:
          """Handle selection of item to remove from matches"""
      def activate_group(self, group_name: str):
          """Activate a group"""
          if group_name == "persistent":
--            print(
++            self._exit_error(
--                "Error: 'persistent' group is always active and cannot be manually activated"
++                "'persistent' group is always active and cannot be manually activated"
+             )
--            return
          success = self.manager.activate_group(group_name)
          if success:
              print(f"✓ Activated group '{group_name}'")
              print("Changes are now active in new shell sessions")
              self.offer_auto_source()
++            self._exit_success()  # Explicit success
          else:
--            print(f"Error: Group '{group_name}' not found in configuration")
              available = self.manager.get_groups()
              if available:
--                print(f"Available groups: {', '.join(available)}")
++                self._exit_error(
++                    f"Group '{group_name}' not found. Available groups: {', '.join(available)}"
++                )
++            else:
++                self._exit_error(f"Group '{group_name}' not found in configuration")
      def deactivate_group(self, group_name: str):
          """Deactivate a group"""
          if group_name == "persistent":
--            print("Error: 'persistent' group cannot be deactivated")
++            self._exit_error("'persistent' group cannot be deactivated")
--            return
          success = self.manager.deactivate_group(group_name)
          if success:
              self.offer_auto_source()
          else:
              print(f"Group '{group_name}' was not active")
++            # Not an error - deactivating inactive group is idempotent
++
++        self._exit_success()  # Always exit success for idempotent operation
      def source_command(self, shell: str = None):
          """Output source command for eval"""
          # Output the source command that can be eval'd
          print(f"source {loader_path}")
++        self._exit_success()  # Explicit success
      # Settings commands
      def settings_init(self):
+                 )
                  if response not in ["y", "yes"]:
                      print("Cancelled")
--                    return
++                    self._exit_success()  # User cancelled - not an error
              except (KeyboardInterrupt, EOFError):
                  print("\nCancelled")
--                return
++                self._exit_error("Operation cancelled by user", code=2)
          settings.create_default_settings_file()
          print(f"✓ Created settings file at {settings._settings_path}")
          print("\nYou can now customize your shtick behavior by editing this file.")
++        self._exit_success()  # Explicit success
      def settings_show(self):
          """Show current settings"""
              print("(No settings file found - using defaults)")
              print("Run 'shtick settings init' to create one")
++        self._exit_success()  # Explicit success
++
      def settings_set(self, key: str, value: str):
          """Set a specific setting value"""
          from shtick.settings import Settings
          # Parse the key (e.g., "generation.shells")
          parts = key.split(".")
          if len(parts) != 2:
--            print(
++            self._exit_error(
--                f"Error: Invalid key format. Use 'section.key' (e.g., 'generation.shells')"
++                "Invalid key format. Use 'section.key' (e.g., 'generation.shells')"
+             )
--            sys.exit(1)
          section, setting_key = parts
          # Validate section
          if section not in ["generation", "behavior", "performance"]:
--            print(
++            self._exit_error(
--                f"Error: Invalid section '{section}'. Must be one of: generation, behavior, performance"
++                f"Invalid section '{section}'. Must be one of: generation, behavior, performance"
+             )
--            sys.exit(1)
          # Get the section object
          section_obj = getattr(settings, section)
          if not hasattr(section_obj, setting_key):
              print(f"Error: Invalid key '{setting_key}' for section '{section}'")
              print(f"Valid keys: {', '.join(vars(section_obj).keys())}")
--            sys.exit(1)
++            self._exit_error(f"Invalid key '{setting_key}'")
          # Parse the value based on type
          current_value = getattr(section_obj, setting_key)
                  # String value
                  parsed_value = value
          except Exception as e:
--            print(f"Error parsing value: {e}")
++            self._exit_error(f"Error parsing value: {e}")
--            sys.exit(1)
          # Set the value
          setattr(section_obj, setting_key, parsed_value)
          # Save settings
++        try:
              settings.save()
--
              print(f"✓ Set {key} = {parsed_value}")
              print(f"Settings saved to {settings._settings_path}")
++            self._exit_success()  # Explicit success
++        except Exception as e:
++            self._exit_error(f"Failed to save settings: {e}")
++
++    # Group management commands
++    def group_create(self, name: str, description: str = None):
++        """Create a new group"""
++        try:
++            # Check if group already exists
++            if self.manager.get_groups() and name in self.manager.get_groups():
++                self._exit_error(f"Group '{name}' already exists")
++
++            # Actually create the empty group
++            from shtick.config import Config, GroupData
++
++            config = self.manager._get_config()
++
++            # Add the new empty group
++            new_group = GroupData(name=name, aliases={}, env_vars={}, functions={})
++            config.groups.append(new_group)
++
++            # Save the config with the new empty group
++            config.save()
++
++            print(f"✓ Created group '{name}'")
++            print(f"\nAdd items to this group with:")
++            print(f"  shtick add alias {name} ll='ls -la'")
++            print(f"  shtick add env {name} DEBUG=1")
++            print(f"\nActivate with:")
++            print(f"  shtick activate {name}")
++
++            self._exit_success()
++        except Exception as e:
++            self._exit_error(str(e))
++
++    def group_rename(self, old_name: str, new_name: str):
++        """Rename a group"""
++        # This would require refactoring the config to support renaming
++        # For now, just indicate it's not implemented
++        self._exit_error("Group rename is not yet implemented")
++
++    def group_remove(self, name: str, force: bool = False):
++        """Remove a group"""
++        # This would require refactoring the config to support group removal
++        # For now, just indicate it's not implemented
++        self._exit_error("Group removal is not yet implemented")
++
++    # Backup commands
++    def backup_create(self, name: str = None):
++        """Create a backup"""
++        try:
++            backup_path = self.manager.backup_config(name)
++            print(f"✓ Created backup: {backup_path}")
++            self._exit_success()
++        except Exception as e:
++            self._exit_error(f"Failed to create backup: {e}")
++
++    def backup_list(self):
++        """List available backups"""
++        try:
++            backups = self.manager.list_backups()
++            if not backups:
++                print("No backups found")
++            else:
++                print("Available backups:")
++                for backup in backups:
++                    from datetime import datetime
++
++                    mtime = datetime.fromtimestamp(backup["modified"]).strftime(
++                        "%Y-%m-%d %H:%M:%S"
++                    )
++                    size_kb = backup["size"] / 1024
++                    print(f"  {backup['name']} ({size_kb:.1f} KB, modified: {mtime})")
++            self._exit_success()
++        except Exception as e:
++            self._exit_error(f"Failed to list backups: {e}")
++
++    def backup_restore(self, name: str):
++        """Restore from backup"""
++        try:
++            if self.manager.restore_backup(name):
++                print(f"✓ Restored from backup: {name}")
++                print("Run 'shtick generate' to regenerate shell files")
++                self._exit_success()
++            else:
++                self._exit_error(f"Backup '{name}' not found")
++        except Exception as e:
++            self._exit_error(f"Failed to restore backup: {e}")
++
++
++# Return code conventions:
++# 0 - Success
++# 1 - General error (invalid arguments, missing files, etc.)
++# 2 - User cancelled operation
++# 3 - Permission denied (currently not used, but reserved)
++# 4 - Resource not found when it should exist (currently not used, but reserved)

src/shtick/config.pymodified

          data = {}
          for group in groups:
              group_data = {}
--            if group.aliases:
++            # Always include the sections, even if empty
--                group_data["aliases"] = group.aliases
++            group_data["aliases"] = group.aliases if group.aliases else {}
--            if group.env_vars:
++            group_data["env_vars"] = group.env_vars if group.env_vars else {}
--                group_data["env_vars"] = group.env_vars
++            group_data["functions"] = group.functions if group.functions else {}
--            if group.functions:
--                group_data["functions"] = group.functions
--            if group_data:
              data[group.name] = group_data
          with open(config_path, "wb") as f:
              tomli_w.dump(data, f)
      except ImportError:
--        # Fallback with proper escaping
++        # Enhanced fallback that writes proper nested TOML structure
--        data = {}
--        for group in groups:
--            if group.aliases:
--                data[f"{group.name}.aliases"] = group.aliases
--            if group.env_vars:
--                data[f"{group.name}.env_vars"] = group.env_vars
--            if group.functions:
--                data[f"{group.name}.functions"] = group.functions
--
--        # Write TOML manually with proper escaping
          with open(config_path, "w") as f:
--            # Sort sections for consistent output
++            # Write each group
--            for section in sorted(data.keys()):
++            for group in groups:
--                items = data[section]
++                # Write main group header
--                f.write(f"[{section}]\n")
++                f.write(f"[{group.name}]\n")
--                # Sort items within section
++
--                for key in sorted(items.keys()):
++                # Write aliases section
--                    value = items[key]
++                f.write(f"[{group.name}.aliases]\n")
--                    # Use proper TOML escaping
++                for key in sorted(group.aliases.keys()):
++                    value = group.aliases[key]
                      escaped_value = escape_toml_value(value)
                      f.write(f"{key} = {escaped_value}\n")
--                f.write("\n")
++
++                # Write env_vars section
++                f.write(f"\n[{group.name}.env_vars]\n")
++                for key in sorted(group.env_vars.keys()):
++                    value = group.env_vars[key]
++                    escaped_value = escape_toml_value(value)
++                    f.write(f"{key} = {escaped_value}\n")
++
++                # Write functions section
++                f.write(f"\n[{group.name}.functions]\n")
++                for key in sorted(group.functions.keys()):
++                    value = group.functions[key]
++                    escaped_value = escape_toml_value(value)
++                    f.write(f"{key} = {escaped_value}\n")
++
++                f.write("\n")  # Empty line between groups
  @dataclass
                          f"Unknown or invalid section '{section_name}' in group '{group_name}'"
+                     )
--            # Create GroupData object if group has any items
++            # Create GroupData object (allow empty groups)
              new_group = GroupData(
                  name=group_name,
                  aliases=group_data["aliases"],
                  functions=group_data["functions"],
+             )
--            if new_group.total_items > 0:
++            # Always add the group, even if empty
              self.groups.append(new_group)
++
++            if new_group.total_items > 0:
                  logger.debug(
                      f"Created group '{group_name}' with {len(group_data['aliases'])} aliases, "
                      f"{len(group_data['env_vars'])} env_vars, {len(group_data['functions'])} functions"
+                 )
              else:
--                logger.warning(f"Group '{group_name}' has no items, skipping")
++                logger.debug(f"Created empty group '{group_name}'")
          logger.debug(
              f"Final groups loaded: {[g.name for g in self.groups]} (total: {len(self.groups)})"
      def save(self) -> None:
          """Save the current configuration back to TOML file with secure escaping"""
++        # Check if we should backup
++        from .settings import Settings
++
++        settings = Settings()
++
++        if settings.behavior.backup_on_save and os.path.exists(self.config_path):
++            # Create automatic backup
++            from datetime import datetime
++
++            backup_dir = os.path.join(os.path.dirname(self.config_path), "backups")
++            os.makedirs(backup_dir, exist_ok=True)
++
++            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
++            backup_path = os.path.join(backup_dir, f"config_auto_{timestamp}.toml")
++
++            import shutil
++
++            shutil.copy2(self.config_path, backup_path)
++            logger.debug(f"Created automatic backup: {backup_path}")
++
++            # Clean up old auto backups (keep last 10)
++            auto_backups = sorted(
++                [
++                    f
++                    for f in os.listdir(backup_dir)
++                    if f.startswith("config_auto_") and f.endswith(".toml")
++                ]
++            )
++            if len(auto_backups) > 10:
++                for old_backup in auto_backups[:-10]:
++                    os.remove(os.path.join(backup_dir, old_backup))
++
++        # Save normally
          save_config_securely(self.config_path, self.groups)
      def get_group(self, group_name: str) -> Optional[GroupData]:

src/shtick/security.pymodified

  """
--Security validation functions for shtick
++Security validation functions for shtick - FIXED FOR GENERATE COMMAND
  """
  import os
          raise ValueError(f"Value too long: maximum {max_length} characters")
--def validate_config_path(path: str) -> str:
++def validate_config_path(path: str, for_generate: bool = False) -> str:
      """
      Validate and sanitize config path for security.
      Args:
          path: Path to validate
++        for_generate: If True, use relaxed validation for generate command
      Returns:
          Validated absolute path
          if ".." in path:
              raise ValueError("Directory traversal detected")
++        # Ensure .toml extension
++        if resolved.suffix != ".toml":
++            raise ValueError("Config file must have .toml extension")
++
++        # For generate command, use relaxed validation
++        if for_generate:
++            # Just ensure the file exists and isn't in system directories
++            if not resolved.exists():
++                raise ValueError("Config file not found")
++
++            # Still block system directories
++            if any(
++                resolved_str.startswith(forbidden)
++                for forbidden in FORBIDDEN_SYSTEM_PATHS
++            ):
++                raise ValueError("Access to system directories is forbidden")
++
++            return resolved_str
++
++        # For other commands, use strict validation
          # Block system directories
          if any(
              resolved_str.startswith(forbidden) for forbidden in FORBIDDEN_SYSTEM_PATHS
          ):
--            raise ValueError(f"Access to system directories is forbidden")
++            raise ValueError("Access to system directories is forbidden")
          # Ensure it's under user's home or current directory
          home = Path.home()
          cwd = Path.cwd()
++        # Check both the original home and current home (for tests)
++        original_home = os.environ.get("SHTICK_ORIGINAL_HOME")
++        if original_home:
++            original_home_path = Path(original_home)
++            if resolved.is_relative_to(original_home_path):
++                return resolved_str
++
          if not (resolved.is_relative_to(home) or resolved.is_relative_to(cwd)):
              raise ValueError("Config path must be under home or current directory")
--        # Ensure .toml extension
--        if resolved.suffix != ".toml":
--            raise ValueError("Config file must have .toml extension")
--
          return resolved_str
      except Exception as e:

src/shtick/shtick.pymodified

              logger.error(f"Error generating shell files: {e}")
              return False
++    def backup_config(self, backup_name: str = None) -> str:
++        """Create a backup of current configuration"""
++        import shutil
++        from datetime import datetime
++
++        config = self._get_config()
++        backup_dir = os.path.join(os.path.dirname(config.config_path), "backups")
++        os.makedirs(backup_dir, exist_ok=True)
++
++        if backup_name:
++            backup_filename = f"config_{backup_name}.toml"
++        else:
++            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
++            backup_filename = f"config_backup_{timestamp}.toml"
++
++        backup_path = os.path.join(backup_dir, backup_filename)
++
++        # Copy current config
++        if os.path.exists(config.config_path):
++            shutil.copy2(config.config_path, backup_path)
++            return backup_path
++        else:
++            raise FileNotFoundError("No config file to backup")
++
++    def list_backups(self) -> List[Dict[str, str]]:
++        """List all available backups"""
++        config = self._get_config()
++        backup_dir = os.path.join(os.path.dirname(config.config_path), "backups")
++
++        if not os.path.exists(backup_dir):
++            return []
++
++        backups = []
++        for file in sorted(os.listdir(backup_dir), reverse=True):
++            if file.endswith(".toml"):
++                file_path = os.path.join(backup_dir, file)
++                stat = os.stat(file_path)
++                backups.append(
++                    {
++                        "name": file,
++                        "path": file_path,
++                        "size": stat.st_size,
++                        "modified": stat.st_mtime,
++                    }
++                )
++
++        return backups
++
++    def restore_backup(self, backup_name: str) -> bool:
++        """Restore configuration from a backup"""
++        import shutil
++
++        config = self._get_config()
++        backup_dir = os.path.join(os.path.dirname(config.config_path), "backups")
++
++        # Find backup file - try multiple naming patterns
++        backup_path = None
++        possible_names = [
++            backup_name,  # exact name
++            f"{backup_name}.toml",  # add extension
++            f"config_{backup_name}",  # add prefix
++            f"config_{backup_name}.toml",  # add both
++        ]
++
++        for name in possible_names:
++            full_path = os.path.join(backup_dir, name)
++            if os.path.exists(full_path):
++                backup_path = full_path
++                break
++
++        if not backup_path:
++            return False
++
++        # Create backup of current before restoring
++        try:
++            self.backup_config("before_restore")
++        except:
++            pass  # Current config might not exist
++
++        # Restore
++        shutil.copy2(backup_path, config.config_path)
++
++        # Reload config and regenerate
++        self._load_config(create_if_missing=False)
++        self.generate_shell_files()
++
++        return True
++
      def get_source_command(self, shell: Optional[str] = None) -> Optional[str]:
          """
          Get the source command for loading shtick in current session.