fix: Enhance synthesis task management and export functionality

[Dallas98]

No description provided.

In general terms, we need to ensure that any user-controlled path is validated and constrained before being used with filesystem APIs. In this case, we should ensure that output_path (if provided) resolves to a subdirectory of a server-controlled base directory, after normalizing the path. If it does not, we should reject it with a clear error. We should also avoid letting the user force absolute paths.

The best fix here is to add a helper method in SynthesisDatasetExporter that computes a safe output directory: it should decide on a base export root (for example, a fixed directory under the application’s working directory), normalize the combination of that root and any user-supplied output_path, and then verify that the resulting path stays under the root. Then export_data should call this helper instead of using self._output_path directly. This maintains the existing behavior (allowing per-request subdirectories) but prevents directory traversal and arbitrary absolute paths.

Concretely, in runtime/datamate-python/app/module/generation/service/export_service.py:

1. Add a private method, e.g. _get_safe_output_dir, to SynthesisDatasetExporter:

   • If self._output_path is falsy: return _get_default_output_dir() (existing behavior).
   • Otherwise:
     • Choose a base root, for example base_root = os.path.abspath(self._get_default_output_dir()). This keeps everything under whatever default export root the app already uses.
     • Normalize the user-specified relative path: safe_rel = os.path.normpath(self._output_path).
     • Reject absolute paths or paths that start with os.pardir (..) after normalization, by raising SynthesisExportError.
     • Compose the final path: candidate = os.path.abspath(os.path.join(base_root, safe_rel)).
     • Verify that candidate starts with base_root + os.sep or equals base_root. If not, raise SynthesisExportError.
     • Return candidate.

2. Update export_data so that line 151 uses output_dir = self._get_safe_output_dir() instead of self._output_path or self._get_default_output_dir().

No new imports are needed beyond os, which is already imported. All changes are confined to SynthesisDatasetExporter in export_service.py.

---

In general, to fix uncontrolled path usage you should (a) restrict writes to a known safe base directory and/or (b) normalize and validate any user-provided path segments before using them with filesystem APIs. For paths that may include subdirectories, the standard pattern is: choose a fixed base_dir, compute full_path = os.path.normpath(os.path.join(base_dir, user_path)), then ensure full_path is still under base_dir before creating directories or opening files.

For this codebase, the minimal, non‑breaking fix is:

1. Introduce a helper on SynthesisDatasetExporter that turns self._output_path (which may be user-controlled) into a validated, absolute directory under a server-controlled root. We can:

   • Pick a safe root directory, e.g. the system temp directory returned by tempfile.gettempdir() (consistent with _get_default_output_dir), and create a fixed subfolder such as "synthesis_exports".
   • If self._output_path is provided, treat it as a subdirectory or file name under that root, not as an absolute path. Normalize with os.path.normpath and check that the resulting resolved directory starts with the chosen root (prefix check on absolute paths).
   • If the check fails, raise SynthesisExportError.

2. Use this helper both where the directory is created (export_data) and where _write_jsonl constructs parent directories:

   • In export_data, replace output_dir = self._output_path or self._get_default_output_dir() with logic that computes a safe output_dir using the helper.
   • In _write_jsonl, derive the parent directory with os.path.dirname(path) and still call os.makedirs(..., exist_ok=True) but only after path has been constructed with the validated output_dir.

3. Keep the external behaviour similar: callers can still pass output_path, but it will now be interpreted safely (as a subpath under the export root) instead of an arbitrary filesystem location.

Concretely, all changes are limited to runtime/datamate-python/app/module/generation/service/export_service.py:

• Add a new private method _get_safe_output_dir near _get_default_output_dir that:

  • Imports tempfile locally (like _get_default_output_dir).
  • Defines base_root = os.path.join(tempfile.gettempdir(), "synthesis_exports").
  • If self._output_path is falsy, returns base_root.
  • Otherwise, builds candidate = os.path.join(base_root, self._output_path), normalizes to normalized = os.path.normpath(candidate), and ensures os.path.commonpath([normalized, base_root]) == base_root. If not, raise SynthesisExportError.
  • Returns normalized.

• Modify export_data so output_dir is assigned by calling self._get_safe_output_dir() and then os.makedirs(output_dir, exist_ok=True) remains.

No changes are needed in generation_api.py or to imports beyond using existing os and a local tempfile import inside _get_safe_output_dir (similar to _get_default_output_dir).

---