refactor(processing): move tmp_dir lifecycle management to CLI

Move temporary directory creation and cleanup from ExtractionConfig to
CLI to make the lifecycle explicit and prevent unintended cleanup.

The implicit atexit cleanup in ExtractionConfig could unexpectedly
remove user-provided directories. This change moves that responsibility
to the CLI layer where it's visible and under explicit control.

Changes:
- ExtractionConfig.tmp_dir defaults to system temp (no auto-cleanup)
- Renamed tmp_dir() context manager to task_tmp_dir()
- task_tmp_dir() creates and cleans up task-specific subdirectories
- CLI explicitly creates unblob temp directory and manages cleanup
- Tests updated for proper sandbox isolation

Result: Library code has no implicit cleanup. CLI owns the lifecycle.
Users can safely provide their own tmp_dir without cleanup surprises.

Author: e3krisztian

python/unblob/cli.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 import atexit
+import shutil
 import sys
+import tempfile
 from collections.abc import Iterable
 from importlib.metadata import version
 from pathlib import Path
@@ -363,6 +365,9 @@ def cli(
     extra_magics_to_skip = () if clear_skip_magics else DEFAULT_SKIP_MAGIC
     skip_magic = tuple(sorted(set(skip_magic).union(extra_magics_to_skip)))
 
+    # Create dedicated unblob temp directory
+    unblob_tmp_dir = Path(tempfile.mkdtemp(prefix="unblob-", dir=tempfile.gettempdir()))
+
     config = ExtractionConfig(
         extract_root=extract_root,
         force_extract=force,
@@ -382,13 +387,25 @@ def cli(
         progress_reporter=NullProgressReporter
         if verbose
         else RichConsoleProgressReporter,
+        tmp_dir=unblob_tmp_dir,
     )
 
     logger.info("Creating extraction directory", extract_root=extract_root)
     extract_root.mkdir(parents=True, exist_ok=True)
     logger.info("Start processing file", file=file)
     sandbox = Sandbox(config, log_path, report_file)
     process_results = sandbox.run(process_file, config, file, report_file)
+
+    # Clean up the temp directory we created
+    try:
+        shutil.rmtree(unblob_tmp_dir)
+    except Exception as e:
+        logger.warning(
+            "Failed to clean up tmp_dir",
+            tmp_dir=unblob_tmp_dir,
+            exc_info=e,
+        )
+
     if verbose == 0:
         if skip_extraction:
             print_scan_report(process_results)

python/unblob/processing.py

@@ -1,4 +1,3 @@
-import atexit
 import multiprocessing
 import os
 import shutil
@@ -104,21 +103,7 @@ class ExtractionConfig:
     dir_handlers: DirectoryHandlers = BUILTIN_DIR_HANDLERS
     verbose: int = 1
     progress_reporter: type[ProgressReporter] = NullProgressReporter
-    tmp_dir: Path = attrs.field(
-        factory=lambda: Path(tempfile.mkdtemp(prefix="unblob-tmp-"))
-    )
-
-    def __attrs_post_init__(self):
-        atexit.register(self._cleanup_tmp_dir)
-
-    def _cleanup_tmp_dir(self):
-        if isinstance(self.tmp_dir, Path) and self.tmp_dir.exists():
-            try:
-                shutil.rmtree(self.tmp_dir)
-            except Exception as e:
-                logger.warning(
-                    "Failed to clean up tmp_dir", tmp_dir=self.tmp_dir, exc_info=e
-                )
+    tmp_dir: Path = attrs.field(factory=lambda: Path(tempfile.gettempdir()))
 
     def _get_output_path(self, path: Path) -> Path:
         """Return path under extract root."""
@@ -247,22 +232,44 @@ def write_json_report(report_file: Path, process_result: ProcessResult):
 
 
 @contextmanager
-def tmp_dir(path):
-    """Context manager that temporarily sets all temp directory env vars."""
+def task_tmp_dir(parent_tmp_dir):
+    """Context manager that creates a task-specific temp subdirectory.
+
+    Creates a subdirectory under parent_tmp_dir, sets all temp env vars to it,
+    yields the path, then cleans up the subdirectory on exit.
+
+    The parent_tmp_dir itself is NOT cleaned up - caller is responsible for that.
+    """
     tmp_vars = ("TMP", "TMPDIR", "TEMP", "TEMPDIR")
     saved = {}
+
+    # Create task-specific subdirectory
+    task_temp = Path(tempfile.mkdtemp(dir=parent_tmp_dir, prefix="unblob-task-"))
+
     try:
+        # Override env vars to point to task subdirectory
         for var in tmp_vars:
             saved[var] = os.environ.get(var)
-            os.environ[var] = str(path)
-        yield
+            os.environ[var] = str(task_temp)
+        yield task_temp
     finally:
+        # Restore original env vars
         for var, original in saved.items():
             if original is None:
                 os.environ.pop(var, None)
             else:
                 os.environ[var] = original
 
+        # Clean up the task subdirectory (NOT the parent)
+        try:
+            shutil.rmtree(task_temp)
+        except Exception as e:
+            logger.warning(
+                "Failed to clean up task temp dir",
+                task_temp=task_temp,
+                exc_info=e,
+            )
+
 
 class Processor:
     def __init__(self, config: ExtractionConfig):
@@ -281,7 +288,7 @@ def __init__(self, config: ExtractionConfig):
     def process_task(self, task: Task) -> TaskResult:
         result = TaskResult(task=task)
         try:
-            with tmp_dir(self._config.tmp_dir.as_posix()):
+            with task_tmp_dir(self._config.tmp_dir):
                 self._process_task(result, task)
         except Exception as exc:
             self._process_error(result, exc)

tests/test_cli.py

@@ -273,8 +273,8 @@ def test_archive_success(
         handlers=BUILTIN_HANDLERS,
         verbose=expected_verbosity,
         progress_reporter=expected_progress_reporter,
+        tmp_dir=mock.ANY,
     )
-    config.tmp_dir = mock.ANY
     process_file_mock.assert_called_once_with(config, in_path, None)
     logger_config_mock.assert_called_once_with(expected_verbosity, tmp_path, log_path)
 

tests/test_sandbox.py

@@ -21,6 +21,9 @@ def extraction_config(extraction_config, tmp_path):
     extraction_config.extract_root = tmp_path / "extract" / "root"
     # parent has to exist
     extraction_config.extract_root.parent.mkdir()
+    # Set tmp_dir to a specific directory under tmp_path to avoid conflicts
+    extraction_config.tmp_dir = tmp_path / "unblob_tmp"
+    extraction_config.tmp_dir.mkdir()
     return extraction_config