classifyre-cli 0.4.56__tar.gz → 0.4.58__tar.gz

classifyre_cli-0.4.58/.turbo/turbo-build.log

@@ -0,0 +1,3 @@
+$ uv sync
+Resolved 300 packages in 202ms
+Checked 51 packages in 3ms

{classifyre_cli-0.4.56 → classifyre_cli-0.4.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classifyre-cli
-Version: 0.4.56
+Version: 0.4.58
 Summary: Classifyre CLI — scan and classify unstructured data sources
 License: MIT
 Keywords: data,ingestion,metadata,pii,secrets,unstructured
@@ -54,7 +54,7 @@ Commands:
 - `test` - test source connection.
 - `discover` - discover source resources.
 - `extract` - run extraction and emit batched output.
-- `sandbox` - run sandbox parsing/detectors for a local file.
+- `evaluate-file` - internally evaluate detectors against one local file.
 
 ## Extract Output Model
 
@@ -78,7 +78,7 @@ Default behavior:
 Global/common:
 
 - `--debug` - enable debug logging.
-- `--detectors-file <path>` - sandbox only.
+- `--detectors-file <path>` - file evaluation only.
 
 Extract output options:
 

{classifyre_cli-0.4.56 → classifyre_cli-0.4.58}/README.md

@@ -37,7 +37,7 @@ Commands:
 - `test` - test source connection.
 - `discover` - discover source resources.
 - `extract` - run extraction and emit batched output.
-- `sandbox` - run sandbox parsing/detectors for a local file.
+- `evaluate-file` - internally evaluate detectors against one local file.
 
 ## Extract Output Model
 
@@ -61,7 +61,7 @@ Default behavior:
 Global/common:
 
 - `--debug` - enable debug logging.
-- `--detectors-file <path>` - sandbox only.
+- `--detectors-file <path>` - file evaluation only.
 
 Extract output options:
 

{classifyre_cli-0.4.56 → classifyre_cli-0.4.58}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classifyre/cli",
-  "version": "0.4.56",
+  "version": "0.4.58",
   "private": true,
   "scripts": {
     "build": "uv sync",

{classifyre_cli-0.4.56 → classifyre_cli-0.4.58}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "classifyre-cli"
-version = "0.4.56"
+version = "0.4.58"
 description = "Classifyre CLI — scan and classify unstructured data sources"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -60,7 +60,7 @@ privacy = [
     # phonenumbers 9.x introduced lazy region loading via __import__ which fails
     # mid-run in frozen/venv contexts. 8.x eagerly loads all data at import time,
     # avoiding ModuleNotFoundError during Presidio phone number analysis.
-    "phonenumbers>=8.13.0,<10.0.0",
+    "phonenumbers>=8.13.0,<9.0.0",
     "numpy>=1.26.0,<3.0.0",
 ]
 security = [
@@ -135,6 +135,18 @@ file-processing = [
     "openpyxl>=3.1.5",
     "chardet>=7.4.3",
     "pyarrow>=18.0.0",
+    # RTF text extraction (tiny, pure Python).
+    "striprtf>=0.0.32",
+    # Secure XML parsing (entity-expansion / XXE hardened stdlib drop-in).
+    "defusedxml>=0.7.1",
+    # Image decoding for GIF-frame extraction and HEIC/HEIF conversion before OCR.
+    "pillow>=12.2.0",
+    "pillow-heif>=1.4.0",
+    # Archive member extraction (zip/tar via stdlib). RAR additionally needs an
+    # external unrar/unar/bsdtar backend at runtime; rarfile degrades gracefully
+    # when none is installed.
+    "py7zr>=1.1.3",
+    "rarfile>=4.3",
     # Table layer: Iceberg metadata resolution + SQL over Parquet without Spark.
     "pyiceberg>=0.9.0",
     "duckdb>=1.1.0",
@@ -152,7 +164,8 @@ video = [
 ]
 ocr = [
     { include-group = "file-processing" },
-    "docling>=2.94.0",
+    # >=2.113 for the OpenDocument (odt/ods/odp) and email (eml/msg) backends.
+    "docling>=2.113.0",
     "opencv-python-headless>=5.0.0.93,<6.0.0",
     "rapidocr-onnxruntime>=1.4.0",
     # torchvision is a transitive dep of docling-ibm-models, but [tool.uv.sources]

classifyre_cli-0.4.58/src/file_evaluation/__init__.py

@@ -0,0 +1,5 @@
+"""Internal runner for evaluating detectors on local files."""
+
+from .runner import FileEvaluationRunner
+
+__all__ = ["FileEvaluationRunner"]

{classifyre_cli-0.4.56/src/sandbox → classifyre_cli-0.4.58/src/file_evaluation}/runner.py

@@ -1,4 +1,4 @@
-"""SandboxRunner: run detectors on a local file."""
+"""FileEvaluationRunner: run detectors on an ephemeral local file."""
 
 from __future__ import annotations
 
@@ -15,11 +15,15 @@ from ..utils.file_parser import ParsedFile, parse_file
 logger = logging.getLogger(__name__)
 
 
-class SandboxRunner:
+class FileEvaluationRunner:
     """Run a set of detectors against a single local file."""
 
     def __init__(self, detectors_config: list[dict[str, Any]]) -> None:
         self._config = detectors_config
+        # Detector construction failures, surfaced in the evaluate-file JSON
+        # output so callers can distinguish "misconfigured detector" from
+        # "no findings".
+        self.detector_errors: list[str] = []
 
     def _build_detectors(self) -> list[Any]:
         from ..detectors import get_detector
@@ -41,9 +45,10 @@ class SandboxRunner:
 
                 detector = get_detector(detector_name, typed_config)
                 detectors.append(detector)
-                logger.info(f"Initialized sandbox detector: {detector_name}")
+                logger.info(f"Initialized file-evaluation detector: {detector_name}")
             except Exception as e:
                 logger.error(f"Failed to initialize detector {detector_type}: {e}")
+                self.detector_errors.append(f"{detector_type}: {e}")
 
         return detectors
 
@@ -121,19 +126,23 @@ class SandboxRunner:
                 and self._is_binary_detector(detector)
                 and self._supports_mime(supported, mime_type)
             ):
-                logger.info("Sandbox: dispatching '%s' on file bytes (%s)", label, mime_type)
+                logger.info(
+                    "File evaluation: dispatching '%s' on file bytes (%s)", label, mime_type
+                )
                 tasks.append(detector.detect(_get_raw_bytes(), mime_type))
                 active_detectors.append(detector)
             # Text delivery: text detectors get the extracted text layer.
             elif "text/plain" in supported and text.strip():
                 logger.info(
-                    "Sandbox: dispatching '%s' on extracted text (%d chars)", label, len(text)
+                    "File evaluation: dispatching '%s' on extracted text (%d chars)",
+                    label,
+                    len(text),
                 )
                 tasks.append(detector.detect(text, "text/plain"))
                 active_detectors.append(detector)
             else:
                 logger.info(
-                    "Sandbox: '%s' not dispatched on whole file (supports=%s, file_mime=%s)",
+                    "File evaluation: '%s' not dispatched on whole file (supports=%s, file_mime=%s)",
                     label,
                     supported,
                     file_mime,
@@ -158,18 +167,20 @@ class SandboxRunner:
         for detector, result in zip(active_detectors, results, strict=False):
             label = self._detector_label(detector)
             if isinstance(result, Exception):
-                logger.error("Sandbox: '%s' failed on whole file: %s", label, result)
+                logger.error("File evaluation: '%s' failed on whole file: %s", label, result)
                 continue
             if isinstance(result, list):
                 detector_findings = [f for f in result if isinstance(f, DetectionResult)]
                 logger.info(
-                    "Sandbox: '%s' on whole file → %d finding(s)", label, len(detector_findings)
+                    "File evaluation: '%s' on whole file → %d finding(s)",
+                    label,
+                    len(detector_findings),
                 )
                 for finding in detector_findings:
                     all_findings.append(
                         finding.model_copy(
                             update={
-                                "runner_id": "sandbox",
+                                "runner_id": "file-evaluation",
                                 "detected_at": detected_at,
                             }
                         )
@@ -203,14 +214,14 @@ class SandboxRunner:
         binary_detectors = [d for d in detectors if self._is_binary_detector(d)]
         if not binary_detectors:
             logger.info(
-                "Sandbox: %s embeds images but no image-capable detectors are configured; "
+                "File evaluation: %s embeds images but no image-capable detectors are configured; "
                 "skipping embedded-image scan",
                 mime_type,
             )
             return []
 
         logger.info(
-            "Sandbox: scanning images embedded in %s with image detectors: [%s]",
+            "File evaluation: scanning images embedded in %s with image detectors: [%s]",
             mime_type,
             ", ".join(self._detector_label(d) for d in binary_detectors),
         )
@@ -227,14 +238,14 @@ class SandboxRunner:
             ]
             if not compatible:
                 logger.info(
-                    "Sandbox: embedded image %s (%s, %.0f KB) — no compatible detector",
+                    "File evaluation: embedded image %s (%s, %.0f KB) — no compatible detector",
                     image.location,
                     image.mime_type,
                     size_kb,
                 )
                 continue
             logger.info(
-                "Sandbox: embedded image %s (%s, %.0f KB) → dispatching [%s]",
+                "File evaluation: embedded image %s (%s, %.0f KB) → dispatching [%s]",
                 image.location,
                 image.mime_type,
                 size_kb,
@@ -246,7 +257,7 @@ class SandboxRunner:
                     result = await detector.detect(image.image_bytes, image.mime_type)
                 except Exception as exc:
                     logger.error(
-                        "Sandbox: '%s' failed on embedded image %s: %s",
+                        "File evaluation: '%s' failed on embedded image %s: %s",
                         label,
                         image.location,
                         exc,
@@ -258,7 +269,7 @@ class SandboxRunner:
                     else []
                 )
                 logger.info(
-                    "Sandbox: '%s' on embedded image %s → %d finding(s)",
+                    "File evaluation: '%s' on embedded image %s → %d finding(s)",
                     label,
                     image.location,
                     len(detector_findings),
@@ -267,7 +278,7 @@ class SandboxRunner:
                     findings.append(self._tag_embedded(finding, image.location, detected_at))
 
         logger.info(
-            "Sandbox: embedded-image scan complete — %d image(s) scanned, %d finding(s)",
+            "File evaluation: embedded-image scan complete — %d image(s) scanned, %d finding(s)",
             image_count,
             len(findings),
         )
@@ -296,7 +307,7 @@ class SandboxRunner:
             location = location.model_copy(update={"path": location_label})
         return finding.model_copy(
             update={
-                "runner_id": "sandbox",
+                "runner_id": "file-evaluation",
                 "detected_at": detected_at,
                 "metadata": metadata,
                 "location": location,

{classifyre_cli-0.4.56 → classifyre_cli-0.4.58}/src/main.py

@@ -1,4 +1,5 @@
 import argparse
+import asyncio
 import json
 import logging
 import os
@@ -17,6 +18,7 @@ _SURROGATE_RE = re.compile(r"[\ud800-\udfff]")
 
 _TIMEOUT_PHRASES = ("timed out", "timeout", "connection reset", "errno 110", "connection refused")
 _TIMEOUT_MYSQL_CODES = {2003, 2006, 2013}
+_TEXT_CHUNK_EMIT_ATTEMPTS = 3
 
 
 def _is_timeout_error(exc: BaseException) -> bool:
@@ -43,6 +45,34 @@ def _sanitize_for_json(value: Any) -> Any:
     return value
 
 
+async def _emit_text_chunks_with_retry(
+    sink: Any,
+    asset_hash: str,
+    artifact: Any,
+    *,
+    attempts: int = _TEXT_CHUNK_EMIT_ATTEMPTS,
+) -> None:
+    """Persist chunk provenance, retrying transient API failures.
+
+    The caller keeps the already-persisted asset successful, but propagates a
+    final failure at run level so missing chunks/embeddings cannot look healthy.
+    """
+    for attempt in range(1, attempts + 1):
+        try:
+            await sink.emit_text_chunks(asset_hash, artifact)
+            return
+        except Exception:
+            if attempt == attempts:
+                raise
+            logger.warning(
+                "Text-chunk emission failed for asset %s (attempt %d/%d); retrying",
+                asset_hash,
+                attempt,
+                attempts,
+            )
+            await asyncio.sleep(0.25 * (2 ** (attempt - 1)))
+
+
 def setup_logging() -> None:
     """Configure the logging facility."""
     logging.basicConfig(
@@ -131,6 +161,10 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
     source_id = args.source_id or os.environ.get("SOURCE_ID")
     if source_id:
         os.environ["SOURCE_ID"] = source_id
+    if getattr(args, "output_rest_url", None):
+        # Sources such as SANDBOX use the same managed-job API base URL as the
+        # REST output sink to list and stream their input content.
+        os.environ["CLASSIFYRE_OUTPUT_REST_URL"] = args.output_rest_url
 
     try:
         try:
@@ -246,13 +280,18 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                         stub_batch = [_asset_to_payload(asset) for asset in raw_batch]
                         for stub in stub_batch:
                             stub["findings"] = []
-                        await sink.emit_batch(stub_batch, skip_findings=True)
-                        output_batch_count += 1
 
+                        # Register BEFORE ingesting: the API stamps per-run
+                        # change_type onto runner_assets rows during ingest, so
+                        # the row must exist or the CREATED stamp is lost and
+                        # first-run counters report every asset as unchanged.
                         hashes = [s["hash"] for s in stub_batch if s.get("hash")]
                         if hasattr(sink, "register_discovered_assets") and hashes:
                             await sink.register_discovered_assets(hashes)
 
+                        await sink.emit_batch(stub_batch, skip_findings=True)
+                        output_batch_count += 1
+
                         all_stubs.extend(raw_batch)
                         logger.info(
                             "Discovered %s assets (total: %s)",
@@ -265,13 +304,11 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
 
                     # --- Phase 2: Processing ---
                     if all_stubs:
-                        import asyncio as _asyncio
-
                         processed_count = 0
                         _pw = worker_pool.max_workers if worker_pool else 4
                         max_concurrent = args.max_concurrent_assets or (_pw * 2)
                         max_concurrent = max(1, max_concurrent)
-                        _asset_semaphore = _asyncio.Semaphore(max_concurrent)
+                        _asset_semaphore = asyncio.Semaphore(max_concurrent)
                         logger.info(
                             "Phase 2 starting: %d assets, pool_workers=%s, max_concurrent_assets=%d",
                             len(all_stubs),
@@ -279,6 +316,7 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                             max_concurrent,
                         )
                         error_count = 0
+                        chunk_errors: list[str] = []
 
                         async def _process_one(asset: Any) -> None:
                             async with _asset_semaphore:
@@ -322,7 +360,24 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                                 if hasattr(sink, "emit_text_chunks"):
                                     artifact = pipeline.take_text_artifact(asset_hash)
                                     if artifact is not None:
-                                        await sink.emit_text_chunks(asset_hash, artifact)
+                                        try:
+                                            await _emit_text_chunks_with_retry(
+                                                sink, asset_hash, artifact
+                                            )
+                                        except Exception as chunk_exc:
+                                            # Findings and the asset remain persisted,
+                                            # preserving B-2's graceful degradation.
+                                            # The run fails after phase 2 so operators
+                                            # cannot mistake missing embeddings for a
+                                            # healthy completed scan.
+                                            detail = f"{asset_hash}: {chunk_exc}"
+                                            chunk_errors.append(detail)
+                                            logger.error(
+                                                "Text-chunk emission exhausted retries"
+                                                " for asset %s: %s",
+                                                asset_hash,
+                                                chunk_exc,
+                                            )
 
                                 if hasattr(sink, "update_asset_status"):
                                     f_total, f_by_sev, f_by_det = _compute_findings_counts(
@@ -350,13 +405,22 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                                     except Exception:
                                         pass
 
-                        tasks = [_asyncio.create_task(_process_one(a)) for a in all_stubs]
-                        await _asyncio.gather(*tasks, return_exceptions=True)
+                        tasks = [asyncio.create_task(_process_one(a)) for a in all_stubs]
+                        await asyncio.gather(*tasks, return_exceptions=True)
                         logger.info(
                             "Phase 2 complete: %d processed, %d errors",
                             processed_count,
                             error_count,
                         )
+                        if chunk_errors:
+                            preview = "; ".join(chunk_errors[:3])
+                            remaining = len(chunk_errors) - 3
+                            if remaining > 0:
+                                preview += f"; and {remaining} more"
+                            raise RuntimeError(
+                                f"Text-chunk emission failed for {len(chunk_errors)}"
+                                f" asset(s) after retries: {preview}"
+                            )
 
                     # Persist the advanced AUTOMATIC sampling cursor (no-op for
                     # other strategies, which return None). Only on the normal
@@ -461,13 +525,13 @@ def run_train_command(args: argparse.Namespace) -> None:
     print(json.dumps(result.to_dict()))
 
 
-def run_sandbox_command(args: argparse.Namespace) -> None:
-    """Execute the sandbox command: parse file + run detectors."""
-    from .sandbox import SandboxRunner
+def run_evaluate_file_command(args: argparse.Namespace) -> None:
+    """Evaluate detector configs against one ephemeral local file."""
+    from .file_evaluation import FileEvaluationRunner
 
     file_path_str: str | None = args.recipe
     if not file_path_str:
-        logger.error("sandbox command requires a file path as the first argument")
+        logger.error("evaluate-file requires a file path as the first argument")
         sys.exit(1)
 
     file_path = Path(file_path_str)
@@ -492,7 +556,7 @@ def run_sandbox_command(args: argparse.Namespace) -> None:
             sys.exit(1)
 
     try:
-        runner = SandboxRunner(detectors)
+        runner = FileEvaluationRunner(detectors)
         parsed, findings = runner.run(file_path)
         if parsed.parse_error:
             logger.warning("File parse warning: %s", parsed.parse_error)
@@ -502,9 +566,11 @@ def run_sandbox_command(args: argparse.Namespace) -> None:
         }
         if parsed.parse_error:
             output["parse_error"] = parsed.parse_error
+        if runner.detector_errors:
+            output["detector_errors"] = runner.detector_errors
         print(json.dumps(_sanitize_for_json(output), ensure_ascii=False))
     except Exception as e:
-        logger.error("Sandbox run failed: %s", e, exc_info=True)
+        logger.error("File evaluation failed: %s", e, exc_info=True)
         sys.exit(1)
 
 
@@ -520,14 +586,14 @@ def main() -> None:
     parser = argparse.ArgumentParser(description="Classifyre Metadata Extraction CLI")
     parser.add_argument(
         "command",
-        choices=["test", "extract", "discover", "sandbox", "train"],
+        choices=["test", "extract", "discover", "evaluate-file", "train"],
         help="Command to run",
     )
     parser.add_argument(
         "recipe",
         nargs="?",
         default=None,
-        help="Path to recipe JSON (or file path for sandbox command)",
+        help="Path to recipe JSON (or file path for evaluate-file)",
     )
     parser.add_argument("--debug", action="store_true", help="Enable debug logging")
     parser.add_argument(
@@ -565,7 +631,7 @@ def main() -> None:
     parser.add_argument(
         "--detectors-file",
         default=None,
-        help="Path to JSON file with detector configs (sandbox command only)",
+        help="Path to JSON file with detector configs (evaluate-file only)",
     )
     # train-command arguments
     parser.add_argument(
@@ -629,8 +695,8 @@ def main() -> None:
     if args.debug:
         logging.getLogger().setLevel(logging.DEBUG)
 
-    if args.command == "sandbox":
-        run_sandbox_command(args)
+    if args.command == "evaluate-file":
+        run_evaluate_file_command(args)
         return
 
     if args.command == "train":

{classifyre_cli-0.4.56 → classifyre_cli-0.4.58}/src/models/generated_detectors.py

@@ -75,6 +75,7 @@ class SourceAssetType(StrEnum):
     ORACLE = 'ORACLE'
     HIVE = 'HIVE'
     POWERBI = 'POWERBI'
+    SANDBOX = 'SANDBOX'
 
 
 class DetectorLifecycleStatus(StrEnum):

{classifyre_cli-0.4.56 → classifyre_cli-0.4.58}/src/models/generated_input.py

@@ -54,6 +54,7 @@ class AssetType(StrEnum):
     LOCAL_FOLDER = 'LOCAL_FOLDER'
     MICROSOFT_365 = 'MICROSOFT_365'
     GOOGLE_WORKSPACE = 'GOOGLE_WORKSPACE'
+    SANDBOX = 'SANDBOX'
 
 
 class DetectorType(StrEnum):
@@ -353,6 +354,7 @@ class Type(StrEnum):
     LOCAL_FOLDER = 'LOCAL_FOLDER'
     MICROSOFT_365 = 'MICROSOFT_365'
     GOOGLE_WORKSPACE = 'GOOGLE_WORKSPACE'
+    SANDBOX = 'SANDBOX'
 
 
 class YouTubeRequired(BaseModel):
@@ -648,6 +650,32 @@ class LocalFolderRequired(BaseModel):
     )
 
 
+class SandboxRequired(BaseModel):
+    """
+    Sandbox files are uploaded separately through the source files API.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
+class SandboxMasked(BaseModel):
+    """
+    Sandbox sources do not require credentials.
+    """
+
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
+class SandboxOptional(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
 class LocalFolderMasked(BaseModel):
     """
     Local folder scans run with the desktop application's filesystem permissions; no credentials are required.
@@ -2170,6 +2198,24 @@ class LocalFolderInput(CoreInput):
     resources: ResourceOverrides | None = None
 
 
+class SandboxInput(CoreInput):
+    type: Literal['SANDBOX'] | None = Field(
+        None, description='Type of the asset or source'
+    )
+    required: SandboxRequired
+    masked: SandboxMasked | None = None
+    optional: SandboxOptional | None = None
+    detectors: list[Detector] | None = Field(
+        None, description='Detectors to run on ingested content'
+    )
+    custom_detectors: list[CustomDetectorSelection] | None = Field(
+        None,
+        description='Reusable custom detector IDs selected from the custom detector catalog.',
+    )
+    sampling: SamplingConfig
+    resources: ResourceOverrides | None = None
+
+
 class AzureBlobStorageInput(CoreInput):
     type: Literal['AZURE_BLOB_STORAGE'] | None = Field(
         None, description='Type of the asset or source'
@@ -2601,7 +2647,7 @@ class ConfluenceOptionalConnection(BaseModel):
     )
 
 
-class Type19(StrEnum):
+class Type20(StrEnum):
     """
     Filter spaces by space type
     """
@@ -2638,7 +2684,7 @@ class ConfluenceOptionalScopeSpaces(BaseModel):
     keys: list[str] | None = Field(
         None, description='Filter spaces by keys (up to 250)', max_length=250
     )
-    type: Type19 | None = Field(None, description='Filter spaces by space type')
+    type: Type20 | None = Field(None, description='Filter spaces by space type')
     status: Status | None = Field(None, description='Filter spaces by status')
     labels: list[str] | None = Field(
         None,
@@ -2904,7 +2950,7 @@ class ServiceDeskOptional(BaseModel):
     content: ServiceDeskOptionalContent | None = None
 
 
-class Type20(StrEnum):
+class Type21(StrEnum):
     """
     Type of the asset or source
     """
@@ -2941,6 +2987,7 @@ class Type20(StrEnum):
     LOCAL_FOLDER = 'LOCAL_FOLDER'
     MICROSOFT_365 = 'MICROSOFT_365'
     GOOGLE_WORKSPACE = 'GOOGLE_WORKSPACE'
+    SANDBOX = 'SANDBOX'
 
 
 class ConfluenceInput(CoreInput):
@@ -4075,7 +4122,8 @@ class IcebergInput(CoreInput):
 
 class SourceInput(
     RootModel[
-        SlackInput
+        SandboxInput
+        | SlackInput
         | S3CompatibleStorageInput
         | LocalFolderInput
         | AzureBlobStorageInput
@@ -4110,7 +4158,8 @@ class SourceInput(
     ]
 ):
     root: (
-        SlackInput
+        SandboxInput
+        | SlackInput
         | S3CompatibleStorageInput
         | LocalFolderInput
         | AzureBlobStorageInput