dar-backup 1.0.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

dar_backup/util.py

@@ -14,6 +14,7 @@ import locale
 import configparser
 import inspect
 import logging
+import json
 
 import os
 import re
@@ -23,12 +24,16 @@ import shutil
 import sys
 import threading
 import traceback
+import urllib.error
+import urllib.request
 
 import dar_backup.__about__ as about
 
 
+
 from argcomplete.completers import ChoicesCompleter
-from datetime import datetime
+from datetime import datetime, date
+from datetime import date 
 from dar_backup.config_settings import ConfigSettings
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
@@ -42,6 +47,26 @@ from typing import Tuple
 logger=None
 secondary_logger=None   
 
+class CleanFormatter(logging.Formatter):
+    """
+    Formatter that ignores exception tracebacks.
+    """
+    def format(self, record):
+        # Save original exception info
+        orig_exc_info = record.exc_info
+        orig_exc_text = record.exc_text
+        
+        # Temporarily hide it
+        record.exc_info = None
+        record.exc_text = None
+        
+        try:
+            return super().format(record)
+        finally:
+            # Restore it so other handlers (like the trace handler) can use it
+            record.exc_info = orig_exc_info
+            record.exc_text = orig_exc_text
+
 #def setup_logging(log_file: str, command_output_log_file: str, log_level: str = "info", log_to_stdout: bool = False) -> logging.Logger:
 def setup_logging(
     log_file: str,
@@ -50,10 +75,15 @@ def setup_logging(
     log_to_stdout: bool = False,
     logfile_max_bytes: int = 26214400,
     logfile_backup_count: int = 5,
+    trace_log_file: str = None,
+    trace_log_max_bytes: int = 10485760,
+    trace_log_backup_count: int = 1
 ) -> logging.Logger:
 
     """
     Sets up logging for the main program and a separate secondary logfile for command outputs.
+    
+    Also sets up a trace log file that captures all logs at DEBUG level including stack traces.
 
     Args:
         log_file (str): The path to the main log file.
@@ -62,6 +92,9 @@ def setup_logging(
         log_to_stdout (bool): If True, log messages will be printed to the console. Defaults to False.
         logfile_max_bytes: max file size of a log file, defailt = 26214400.
         logfile_backup_count: max numbers of logs files, default = 5.
+        trace_log_file (str): Optional path for the trace log file. Defaults to log_file with ".trace.log" suffix.
+        trace_log_max_bytes: max file size of the trace log file, default = 10485760 (10MB).
+        trace_log_backup_count: max numbers of trace log files, default = 1.
 
     Returns:
         a RotatingFileHandler logger instance.
@@ -80,6 +113,7 @@ def setup_logging(
 
         logging.Logger.trace = trace
 
+        # Main log file handler (clean logs)
         file_handler = RotatingFileHandler(
             log_file,
             maxBytes=logfile_max_bytes,
@@ -87,6 +121,23 @@ def setup_logging(
             encoding="utf-8",
         )
 
+        # Trace log file handler (full details)
+        if not trace_log_file:
+            if log_file == "/dev/null":
+                trace_log_file = "/dev/null"
+            else:
+                base, ext = os.path.splitext(log_file)
+                trace_log_file = f"{base}.trace{ext}"
+            
+        trace_handler = RotatingFileHandler(
+            trace_log_file,
+            maxBytes=trace_log_max_bytes,
+            backupCount=trace_log_backup_count,
+            encoding="utf-8",
+        )
+        # Trace handler gets everything (DEBUG level) and keeps tracebacks
+        trace_handler.setLevel(logging.DEBUG)
+
         command_handler = RotatingFileHandler(
             command_output_log_file,
             maxBytes=logfile_max_bytes,
@@ -94,24 +145,35 @@ def setup_logging(
             encoding="utf-8",
         )
 
-        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-        file_handler.setFormatter(formatter)
-        command_handler.setFormatter(formatter)
+        standard_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        clean_formatter = CleanFormatter('%(asctime)s - %(levelname)s - %(message)s')
+        
+        file_handler.setFormatter(clean_formatter)
+        trace_handler.setFormatter(standard_formatter)
+        command_handler.setFormatter(standard_formatter)
 
 
         # Setup main logger
         logger = logging.getLogger("main_logger")
-        logger.setLevel(logging.DEBUG if log_level == "debug" else TRACE_LEVEL_NUM if log_level == "trace" else logging.INFO)
+        # Ensure logger captures everything so trace_handler can see DEBUG messages even if main log_level is INFO
+        logger.setLevel(logging.DEBUG) 
+        
+        # Configure file_handler level based on user preference
+        file_handler.setLevel(logging.DEBUG if log_level == "debug" else TRACE_LEVEL_NUM if log_level == "trace" else logging.INFO)
+        
         logger.addHandler(file_handler)
+        logger.addHandler(trace_handler)
 
         # Setup secondary logger for command outputs
         secondary_logger = logging.getLogger("command_output_logger")
         secondary_logger.setLevel(logging.DEBUG if log_level == "debug" else TRACE_LEVEL_NUM if log_level == "trace" else logging.INFO)
         secondary_logger.addHandler(command_handler)
+        secondary_logger.addHandler(trace_handler)
 
         if log_to_stdout:
             stdout_handler = logging.StreamHandler(sys.stdout)
-            stdout_handler.setFormatter(formatter)
+            stdout_handler.setFormatter(clean_formatter)
+            stdout_handler.setLevel(logging.DEBUG if log_level == "debug" else TRACE_LEVEL_NUM if log_level == "trace" else logging.INFO)
             logger.addHandler(stdout_handler)
 
         return logger
@@ -136,15 +198,29 @@ def get_logger(command_output_logger: bool = False) -> logging.Logger:
     return secondary_logger if command_output_logger else logger
 
 
+def _default_completer_logfile() -> str:
+    try:
+        uid = os.getuid()
+    except AttributeError:
+        uid = None
+    suffix = str(uid) if uid is not None else "unknown"
+    return f"/tmp/dar_backup_completer_{suffix}.log"
+
+
 # Setup completer logger only once
-def _setup_completer_logger(logfile="/tmp/dar_backup_completer.log"):
+def _setup_completer_logger(logfile: str = None):
     logger = logging.getLogger("completer")
     if not logger.handlers:
-        handler = logging.FileHandler(logfile)
-        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-        logger.setLevel(logging.DEBUG)
+        try:
+            logfile = logfile or _default_completer_logfile()
+            handler = logging.FileHandler(logfile)
+            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+            logger.setLevel(logging.DEBUG)
+        except Exception:
+            logger.addHandler(logging.NullHandler())
+            logger.setLevel(logging.DEBUG)
     return logger
 
 # Singleton logger for completer debugging
@@ -200,10 +276,80 @@ def show_version():
     print(f"{script_name} source code is here: https://github.com/per2jensen/dar-backup")
     print(about.__license__)
 
+
+def send_discord_message(
+    content: str,
+    config_settings: typing.Optional[ConfigSettings] = None,
+    timeout_seconds: int = 10
+) -> bool:
+    """
+    Send a message to a Discord webhook if configured either in the config file or via environment.
+
+    The environment varible DAR_BACKUP_DISCORD_WEBHOOK_URL, when set, takes precedence over the config file variable 
+    with the same name. If neither is defined, the function logs an info-level message and returns False.
+
+    Returns:
+        bool: True if the message was sent successfully, otherwise False.
+    """
+    log = get_logger()
+
+    config_webhook = getattr(config_settings, "dar_backup_discord_webhook_url", None) if config_settings else None
+    env_webhook = os.environ.get("DAR_BACKUP_DISCORD_WEBHOOK_URL")
+
+    webhook_url = env_webhook or config_webhook
+    source = "environment" if env_webhook else ("config file" if config_webhook else None)
+
+    if not webhook_url:
+        log and log.info("Discord message not sent: DAR_BACKUP_DISCORD_WEBHOOK_URL not configured.")
+        return False
+
+    payload = json.dumps({"content": content}).encode("utf-8")
+    user_agent = f"dar-backup/{about.__version__}"
+
+    request = urllib.request.Request(
+        webhook_url,
+        data=payload,
+        headers={
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": user_agent,
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(request, timeout=timeout_seconds):
+            pass
+        log and log.debug(f"Discord webhook message sent using {source}.")
+        return True
+    except urllib.error.HTTPError as exc:
+        # Attempt to read a short error body for diagnostics
+        body = None
+        try:
+            body = exc.read().decode(errors="replace")
+        except Exception:
+            body = None
+        detail = f" body='{body.strip()}'" if body else ""
+        message = f"Discord webhook HTTP error {exc.code}: {exc.reason}{detail}"
+        if log:
+            log.error(message)
+        else:
+            print(message, file=sys.stderr)
+    except Exception as exc:
+        message = f"Failed to send Discord webhook message: {exc}"
+        if log:
+            log.error(message)
+        else:
+            print(message, file=sys.stderr)
+
+    return False
+
+
 def extract_version(output):
     match = re.search(r'(\d+\.\d+(\.\d+)?)', output)
     return match.group(1) if match else "unknown"
 
+
 def get_binary_info(command):
     """
     Return information about a binary command.
@@ -286,13 +432,64 @@ def requirements(type: str, config_setting: ConfigSettings):
     if type in config_setting.config:
         for key in sorted(config_setting.config[type].keys()):
             script = config_setting.config[type][key]
+            use_run_fallback = (
+                os.getenv("PYTEST_CURRENT_TEST") is not None
+                or getattr(subprocess.run, "__module__", "") != "subprocess"
+            )
             try:
-                result = subprocess.run(script, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True, check=True)
-                logger.debug(f"{type} {key}: '{script}' run, return code: {result.returncode}")
-                logger.debug(f"{type} stdout:\n{result.stdout}")
-                if result.returncode != 0:
-                    logger.error(f"{type} stderr:\n{result.stderr}")
-                    raise RuntimeError(f"{type} {key}: '{script}' failed, return code: {result.returncode}")    
+                if use_run_fallback:
+                    result = subprocess.run(
+                        script,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        shell=True,
+                        check=True
+                    )
+                    logger.debug(f"{type} {key}: '{script}' run, return code: {result.returncode}")
+                    logger.debug(f"{type} stdout:\n{result.stdout}")
+                    if result.returncode != 0:
+                        logger.error(f"{type} stderr:\n{result.stderr}")
+                        raise RuntimeError(f"{type} {key}: '{script}' failed, return code: {result.returncode}")
+                else:
+                    process = subprocess.Popen(
+                        script,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        shell=True
+                    )
+                    stdout_lines = []
+                    stderr_lines = []
+
+                    def read_stream(stream, lines, level):
+                        if stream is None:
+                            return
+                        for line in stream:
+                            logger.log(level, line.rstrip())
+                            lines.append(line)
+
+                    stdout_thread = threading.Thread(
+                        target=read_stream,
+                        args=(process.stdout, stdout_lines, logging.DEBUG)
+                    )
+                    stderr_thread = threading.Thread(
+                        target=read_stream,
+                        args=(process.stderr, stderr_lines, logging.ERROR)
+                    )
+                    stdout_thread.start()
+                    stderr_thread.start()
+
+                    process.wait()
+                    stdout_thread.join()
+                    stderr_thread.join()
+
+                    logger.debug(f"{type} {key}: '{script}' run, return code: {process.returncode}")
+                    if process.returncode != 0:
+                        stderr_text = "".join(stderr_lines)
+                        if stderr_text:
+                            logger.error(f"{type} stderr:\n{stderr_text}")
+                        raise RuntimeError(f"{type} {key}: '{script}' failed, return code: {process.returncode}")
             except subprocess.CalledProcessError as e:
                 logger.error(f"Error executing {key}: '{script}': {e}")
                 raise e
@@ -428,16 +625,14 @@ def expand_path(path: str) -> str:
     return os.path.expanduser(os.path.expandvars(path))
 
 
-
 def backup_definition_completer(prefix, parsed_args, **kwargs):
-    config_path = getattr(parsed_args, 'config_file', '~/.config/dar-backup/dar-backup.conf')
-    config_path = expand_path(config_path)
-    config_file = os.path.expanduser(config_path)
     try:
+        config_file = get_config_file(parsed_args)
         config = ConfigSettings(config_file)
         backup_d_dir = os.path.expanduser(config.backup_d_dir)
         return [f for f in os.listdir(backup_d_dir) if f.startswith(prefix)]
     except Exception:
+        completer_logger.exception("backup_definition_completer failed")
         return []
 
 
@@ -450,46 +645,84 @@ def extract_backup_definition_fallback() -> str:
         str: The value of the --backup-definition argument if found, else an empty string.
     """
     comp_line = os.environ.get("COMP_LINE", "")
-    # Match both "--backup-definition VALUE" and "-d VALUE"
-    match = re.search(r"(--backup-definition|-d)\s+([^\s]+)", comp_line)
-    if match:
-        return match.group(2)
+    try:
+        tokens = shlex.split(comp_line)
+    except ValueError:
+        tokens = comp_line.split()
+
+    for i, token in enumerate(tokens):
+        if token in ("-d", "--backup-definition", "--backup-def"):
+            if i + 1 < len(tokens):
+                return tokens[i + 1]
+        elif token.startswith(("--backup-definition=", "--backup-def=", "-d=")):
+            return token.split("=", 1)[1]
     return ""
 
 
 
 
 def list_archive_completer(prefix, parsed_args, **kwargs):
-    import os
-    import configparser
-    from dar_backup.util import extract_backup_definition_fallback
+    try:
+        import os
+        import configparser
+        from dar_backup.util import extract_backup_definition_fallback
+
+        comp_line = os.environ.get("COMP_LINE", "")
+        if "cleanup" in comp_line and "--cleanup-specific-archives" not in comp_line:
+            return []
+
+        backup_def = (
+            getattr(parsed_args, "backup_definition", None)
+            or getattr(parsed_args, "backup_def", None)
+            or extract_backup_definition_fallback()
+        )
+        head, last = split_archive_list_prefix(prefix)
+        config_path = get_config_file(parsed_args)
+        if not os.path.exists(config_path):
+            return []
 
-    backup_def = getattr(parsed_args, "backup_definition", None) or extract_backup_definition_fallback()
-    config_path = getattr(parsed_args, "config_file", None) or "~/.config/dar-backup/dar-backup.conf"
+        config = configparser.ConfigParser()
+        config.read(config_path)
+        backup_dir = config.get("DIRECTORIES", "BACKUP_DIR", fallback="")
+        backup_dir = os.path.expanduser(os.path.expandvars(backup_dir))
 
-    config_path = os.path.expanduser(os.path.expandvars(config_path))
-    if not os.path.exists(config_path):
-        return []
+        if not os.path.isdir(backup_dir):
+            return []
 
-    config = configparser.ConfigParser()
-    config.read(config_path)
-    backup_dir = config.get("DIRECTORIES", "BACKUP_DIR", fallback="")
-    backup_dir = os.path.expanduser(os.path.expandvars(backup_dir))
+        files = os.listdir(backup_dir)
+        archive_re = re.compile(rf"^{re.escape(backup_def)}_.+_\d{{4}}-\d{{2}}-\d{{2}}\.1\.dar$") if backup_def else re.compile(r".+_\d{4}-\d{2}-\d{2}\.1\.dar$")
 
-    if not os.path.isdir(backup_dir):
-        return []
+        completions = []
+        for fname in files:
+            if not archive_re.match(fname):
+                continue
+            base = fname.rsplit(".1.dar", 1)[0]
+            if last and not base.startswith(last):
+                continue
+            if head:
+                completions.append(f"{head}, {base}")
+            else:
+                completions.append(base)
 
-    files = os.listdir(backup_dir)
-    archive_re = re.compile(rf"^{re.escape(backup_def)}_.+_\d{{4}}-\d{{2}}-\d{{2}}\.1\.dar$") if backup_def else re.compile(r".+_\d{4}-\d{2}-\d{2}\.1\.dar$")
+        completions = sorted(set(completions), key=sort_key)
+        return completions or ["[no matching archives]"]
+    except Exception:
+        completer_logger.exception("list_archive_completer failed")
+        return []
 
-    completions = [
-        f.rsplit(".1.dar", 1)[0]
-        for f in files
-        if archive_re.match(f)
-    ]
 
-    completions = sorted(set(completions), key=sort_key)
-    return completions or ["[no matching archives]"]
+def split_archive_list_prefix(prefix: str) -> tuple[str, str]:
+    """
+    Split a comma-separated archive list into (head, last).
+    Strips whitespace so completions don't include leading/trailing spaces.
+    """
+    if not prefix or "," not in prefix:
+        return ("", prefix.strip())
+    parts = [part.strip() for part in prefix.split(",")]
+    head_parts = [part for part in parts[:-1] if part]
+    head = ", ".join(head_parts)
+    last = parts[-1]
+    return (head, last)
 
 
 
@@ -511,6 +744,7 @@ def sort_key(archive_name: str):
         completer_logger.debug(f"Archive: {archive_name}, Def: {def_name}, Date: {date}")
         return (def_name, date)
     except Exception:
+        completer_logger.exception("sort_key failed")
         return (archive_name, datetime.min)
 
 
@@ -523,52 +757,56 @@ def archive_content_completer(prefix, parsed_args, **kwargs):
     Only entries found in the catalog database (via `dar_manager --list`) are shown.
     """
 
-    from dar_backup.config_settings import ConfigSettings
-    import subprocess
-    import re
-    import os
-    from datetime import datetime
-
-    # Expand config path
-    config_file = expand_path(getattr(parsed_args, "config_file", "~/.config/dar-backup/dar-backup.conf"))
-    config = ConfigSettings(config_file=config_file)
-    #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
-    db_dir = expand_path(getattr(config, 'manager_db_dir', None) or config.backup_dir)
-
-    # Which db files to inspect?
-    backup_def = getattr(parsed_args, "backup_def", None)
-    db_files = (
-        [os.path.join( db_dir, f"{backup_def}.db")]
-        if backup_def
-        else [os.path.join( db_dir, f) for f in os.listdir( db_dir) if f.endswith(".db")]
-    )
+    try:
+        from dar_backup.config_settings import ConfigSettings
+        import subprocess
+        import re
+        import os
+        from datetime import datetime
+
+        # Expand config path
+        config_file = get_config_file(parsed_args)
+        config = ConfigSettings(config_file=config_file)
+        #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
+        db_dir = expand_path(getattr(config, 'manager_db_dir', None) or config.backup_dir)
+
+        # Which db files to inspect?
+        backup_def = getattr(parsed_args, "backup_def", None)
+        db_files = (
+            [os.path.join( db_dir, f"{backup_def}.db")]
+            if backup_def
+            else [os.path.join( db_dir, f) for f in os.listdir( db_dir) if f.endswith(".db")]
+        )
 
-    completions = []
+        completions = []
 
-    for db_path in db_files:
-        if not os.path.exists(db_path):
-            continue
+        for db_path in db_files:
+            if not os.path.exists(db_path):
+                continue
 
-        try:
-            result = subprocess.run(
-                ["dar_manager", "--base", db_path, "--list"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.DEVNULL,
-                text=True,
-                check=True
-            )
-        except subprocess.CalledProcessError:
-            continue
+            try:
+                result = subprocess.run(
+                    ["dar_manager", "--base", db_path, "--list"],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                    text=True,
+                    check=True
+                )
+            except subprocess.CalledProcessError:
+                continue
 
-        for line in result.stdout.splitlines():
-            parts = line.strip().split("\t")
-            if len(parts) >= 3:
-                archive = parts[2].strip()
-                if archive.startswith(prefix):
-                    completions.append(archive)
+            for line in result.stdout.splitlines():
+                parts = line.strip().split("\t")
+                if len(parts) >= 3:
+                    archive = parts[2].strip()
+                    if archive.startswith(prefix):
+                        completions.append(archive)
 
-    completions = sorted(set(completions), key=sort_key)
-    return completions or ["[no matching archives]"]
+        completions = sorted(set(completions), key=sort_key)
+        return completions or ["[no matching archives]"]
+    except Exception:
+        completer_logger.exception("archive_content_completer failed")
+        return []
 
 
 
@@ -578,55 +816,59 @@ def add_specific_archive_completer(prefix, parsed_args, **kwargs):
     but not yet present in the <backup_def>.db catalog.
     If --backup-def is provided, restrict suggestions to that.
     """
-    from dar_backup.config_settings import ConfigSettings
-    import subprocess
-    import re
-    import os
-    from datetime import datetime
-
-    config_file = expand_path(getattr(parsed_args, "config_file", "~/.config/dar-backup/dar-backup.conf"))
-    config = ConfigSettings(config_file=config_file)
-    #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
-    db_dir = expand_path(getattr(config, 'manager_db_dir') or config.backup_dir)
-    backup_dir = config.backup_dir
-    backup_def = getattr(parsed_args, "backup_def", None)
-
-    # Match pattern for archive base names: e.g. test_FULL_2025-04-01
-    dar_pattern = re.compile(r"^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.1\.dar$")
-
-    # Step 1: scan backup_dir for .1.dar files
-    all_archives = set()
-    for fname in os.listdir(backup_dir):
-        match = dar_pattern.match(fname)
-        if match:
-            base = match.group(1)
-            if base.startswith(prefix):
-                if not backup_def or base.startswith(f"{backup_def}_"):
-                    all_archives.add(base)
-
-    # Step 2: exclude ones already present in the .db
-    db_path = os.path.join(db_dir, f"{backup_def}.db") if backup_def else None
-    existing = set()
-
-    if db_path and os.path.exists(db_path):
-        try:
-            result = subprocess.run(
-                ["dar_manager", "--base", db_path, "--list"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.DEVNULL,
-                text=True,
-                check=True
-            )
-            for line in result.stdout.splitlines():
-                parts = line.strip().split("\t")
-                if len(parts) >= 3:
-                    existing.add(parts[2].strip())
-        except subprocess.CalledProcessError:
-            pass
-
-    # Step 3: return filtered list
-    candidates = sorted(archive for archive in all_archives if archive not in existing)
-    return candidates or ["[no new archives]"]
+    try:
+        from dar_backup.config_settings import ConfigSettings
+        import subprocess
+        import re
+        import os
+        from datetime import datetime
+
+        config_file = get_config_file(parsed_args)
+        config = ConfigSettings(config_file=config_file)
+        #db_dir = expand_path((getattr(config, 'manager_db_dir', config.backup_dir)))   # use manager_db_dir if set, else backup_dir
+        db_dir = expand_path(getattr(config, 'manager_db_dir') or config.backup_dir)
+        backup_dir = config.backup_dir
+        backup_def = getattr(parsed_args, "backup_def", None)
+
+        # Match pattern for archive base names: e.g. test_FULL_2025-04-01
+        dar_pattern = re.compile(r"^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.1\.dar$")
+
+        # Step 1: scan backup_dir for .1.dar files
+        all_archives = set()
+        for fname in os.listdir(backup_dir):
+            match = dar_pattern.match(fname)
+            if match:
+                base = match.group(1)
+                if base.startswith(prefix):
+                    if not backup_def or base.startswith(f"{backup_def}_"):
+                        all_archives.add(base)
+
+        # Step 2: exclude ones already present in the .db
+        db_path = os.path.join(db_dir, f"{backup_def}.db") if backup_def else None
+        existing = set()
+
+        if db_path and os.path.exists(db_path):
+            try:
+                result = subprocess.run(
+                    ["dar_manager", "--base", db_path, "--list"],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                    text=True,
+                    check=True
+                )
+                for line in result.stdout.splitlines():
+                    parts = line.strip().split("\t")
+                    if len(parts) >= 3:
+                        existing.add(parts[2].strip())
+            except subprocess.CalledProcessError:
+                pass
+
+        # Step 3: return filtered list
+        candidates = sorted(archive for archive in all_archives if archive not in existing)
+        return candidates or ["[no new archives]"]
+    except Exception:
+        completer_logger.exception("add_specific_archive_completer failed")
+        return []
 
 
 
@@ -735,8 +977,12 @@ def normalize_dir(path: str) -> str:
 
 # Reusable pattern for archive file naming
 archive_pattern = re.compile(
-    r'^.+?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2})\.\d+\.dar'
-    r'(?:\.vol\d+(?:\+\d+)?\.par2|\.par2)?$'
+    r'^.+?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2})'
+    r'(?:'
+    r'\.\d+\.dar(?:\.vol\d+(?:\+\d+)?\.par2|\.par2)?'
+    r'|(?:\.vol\d+(?:\+\d+)?\.par2|\.par2)'
+    r'|\.par2\.manifest\.ini'
+    r')$'
 )
 
 def is_safe_filename(filename: str) -> bool:
@@ -757,4 +1003,119 @@ def is_safe_path(path: str) -> bool:
         and '..' not in normalized.split(os.sep)
     )
 
+def get_config_file(args) -> str:
+    """
+    Returns the config file path based on the following precedence:
+    1. Command-line argument (--config-file)
+    2. Environment variable (DAR_BACKUP_CONFIG_FILE)
+    3. Default path (~/.config/dar-backup/dar-backup.conf)
+    """
+    DEFAULT_CONFIG_FILE = "~/.config/dar-backup/dar-backup.conf"
+
+    env_cf = os.getenv("DAR_BACKUP_CONFIG_FILE")
+    env_cf = env_cf.strip() if env_cf else None
+
+    cli_cf = getattr(args, "config_file", None)
+    cli_cf = cli_cf.strip() if cli_cf else None
+    
+    raw_config = (
+        cli_cf
+        or env_cf
+        or DEFAULT_CONFIG_FILE
+    )
+
+    config_settings_path = os.path.abspath(os.path.expanduser(os.path.expandvars(raw_config)))
+    return config_settings_path
+
+
+
+def is_under_base_dir(candidate: Path, base_dir: Path) -> bool:
+    """
+    True iff candidate resolves under base_dir (symlink-safe).
+    """
+    try:
+        base = base_dir.resolve(strict=True)
+        resolved = candidate.resolve(strict=False)
+    except Exception:
+        return False
+    return resolved == base or base in resolved.parents
+
+
+def safe_remove_file(path_str: str, *, base_dir: Path) -> bool:
+    """
+    Remove a file only if it:
+      - is under base_dir (after resolve),
+      - matches archive naming convention by BASENAME,
+      - is a regular file (not a dir),
+      - is not a symlink (optional hardening).
+    Returns True if removed.
+    """
+    p = Path(path_str)
+
+    # Enforce containment first (defeats ../ and symlink escape)
+    if not is_under_base_dir(p, base_dir):
+        logger.warning("Refusing to delete outside base_dir: %s (base=%s)", p, base_dir)
+        return False
+
+    # Validate filename shape on basename only
+    if not is_safe_filename(p.name):
+        logger.warning("Refusing to delete non-matching filename: %s", p.name)
+        return False
+
+    # Hardening: don't follow symlinks
+    if p.is_symlink():
+        logger.warning("Refusing to delete symlink: %s", p)
+        return False
+
+    # Only delete regular files
+    if not p.is_file():
+        logger.warning("Refusing to delete non-file: %s", p)
+        return False
+
+    p.unlink()
+    return True
+
+
+
+# Allowed archive name:
+#   <definition>_(FULL|DIFF|INCR)_YYYY-MM-DD
+# Example:
+#   pj-homedir_INCR_2025-11-22
+_ARCHIVE_NAME_RE = re.compile(
+    r"^(?P<def>[A-Za-z0-9][A-Za-z0-9._-]{0,127})_"
+    r"(?P<kind>FULL|DIFF|INCR)_"
+    r"(?P<date>\d{4}-\d{2}-\d{2})$"
+)
+
+def is_archive_name_allowed(name: str) -> bool:
+    """
+    Return True iff the archive name is safe and valid.
+
+    Security properties:
+      - name only, never a path (no /, \\, or ..)
+      - strict allowed character set
+      - must be FULL / DIFF / INCR
+      - date must be a real calendar date
+    """
+    if not isinstance(name, str):
+        return False
+
+    name = name.strip()
+
+    # Reject anything path-like
+    if "/" in name or "\\" in name or ".." in name:
+        return False
+
+    m = _ARCHIVE_NAME_RE.match(name)
+    if not m:
+        return False
+
+    # Validate date is real (not just shape)
+    try:
+        date.fromisoformat(m.group("date"))   # <-- FIX
+        # alternatively:
+        # datetime.strptime(m.group("date"), "%Y-%m-%d")
+    except ValueError:
+        return False
 
+    return True