apheris-foundry-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apheris-foundry-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Command-line interface for Apheris Foundry workflows.
 Author: Apheris
 License-Expression: LicenseRef-Apheris-Foundry-Software-License

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apheris-foundry-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "Command-line interface for Apheris Foundry workflows."
 readme = "README.md"
 requires-python = ">=3.10"

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/src/apheris_foundry_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apheris-foundry-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Command-line interface for Apheris Foundry workflows.
 Author: Apheris
 License-Expression: LicenseRef-Apheris-Foundry-Software-License

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/src/apherisfold_cli/commands/foundry.py

@@ -9,6 +9,7 @@ from io import BytesIO
 from pathlib import Path
 from typing import Any
 
+import typer
 from rich import box
 from rich.console import Console, Group
 from rich.panel import Panel
@@ -16,9 +17,10 @@ from rich.table import Table
 from rich.text import Text
 from rich.tree import Tree
 
-from apherisfold_cli.core.errors import EXIT_PRECONDITION, EXIT_USAGE, CLIError
+from apherisfold_cli.core.errors import EXIT_INTERNAL, EXIT_PRECONDITION, EXIT_USAGE, CLIError
 from apherisfold_cli.core.hub_requests import (
     create_foundry_run,
+    download_foundry_run_archive,
     download_foundry_run_artifact,
     get_foundry_run,
     get_foundry_run_logs,
@@ -706,7 +708,7 @@ def foundry_run(
     final = _poll_until_terminal(run_id)
     if json_output:
         run_simple_listing(task_name="foundry.run", payload=final)
-
+        _exit_if_failed_run(final)
         return
 
     final_status = str(final.get("status", ""))
@@ -714,6 +716,7 @@ def foundry_run(
     _CONSOLE.print(f"[{style}]Job {run_id} finished: {final_status}[/{style}]")
     if final.get("error"):
         _CONSOLE.print(f"[red]Error: {final['error']}[/red]")
+    _exit_if_failed_run(final)
 
 
 _DEFAULT_LIST_LIMIT = 30
@@ -959,19 +962,9 @@ def foundry_download_result(
     task_name = "foundry.predict.download-result"
     selected_result_view = validate_result_view(result_view, task=task_name)
     run = get_foundry_run(run_id)
-    artifact = _resolve_download_artifact(run, artifact_id)
-    if artifact is None:
-        raise CLIError(
-            code=EXIT_PRECONDITION,
-            category="precondition",
-            message=(
-                f"No results.zip output is available for Foundry job {run_id}. "
-                f"Check files with: apheris-foundry jobs get --id {run_id}"
-            ),
-            task=task_name,
-        )
 
-    if not _is_results_archive_artifact(artifact):
+    if artifact_id:
+        artifact = _resolve_artifact(run, artifact_id)
         _download_selected_artifact(
             run_id=run_id,
             artifact=artifact,
@@ -981,10 +974,9 @@ def foundry_download_result(
         )
         return
 
-    archive_path = str(artifact.get("path", ""))
     destination = (output_dir or default_results_dir("foundry-predict", run_id)).expanduser().resolve()
     _ensure_download_dir(destination, task_name=task_name)
-    archive_bytes = download_foundry_run_artifact(run_id, archive_path)
+    archive_bytes = download_foundry_run_archive(run_id)
     results = extract_results_archive(
         archive_bytes=archive_bytes,
         output_dir=destination,
@@ -1088,13 +1080,6 @@ def foundry_error(run_id: str) -> None:
     _CONSOLE.print(Group(*panels))
 
 
-def _foundry_results_archive_path(run: dict[str, Any]) -> str:
-    artifact = _resolve_download_artifact(run, None)
-    if artifact is not None:
-        return str(artifact.get("path", ""))
-    return ""
-
-
 def _foundry_file_panels(run: dict[str, Any], *, result_preview: dict[str, Any] | None) -> list[Panel]:
     artifacts = _indexed_artifacts(run)
     workflow = str(run.get("workflow", ""))
@@ -1137,7 +1122,7 @@ def _foundry_commands_panel(run: dict[str, Any], *, result_preview: dict[str, An
     status = str(run.get("status", "")).lower()
     table = Table(box=box.SIMPLE_HEAD, show_header=False, padding=(0, 1), expand=False)
     table.add_column("command", style="cyan", overflow="fold")
-    has_results = _resolve_download_artifact(run, None) is not None
+    has_results = _has_downloadable_results(run)
     if has_results:
         table.add_row(f"{command_prefix} jobs download --id {run_id}")
     table.add_row(f"{command_prefix} jobs get --id {run_id} --artifact-id <id>")
@@ -1217,13 +1202,10 @@ def _slug(value: str) -> str:
     return slug or "artifact"
 
 
-def _resolve_download_artifact(run: dict[str, Any], artifact_id: str | None) -> dict[str, Any] | None:
-    if artifact_id:
-        return _resolve_artifact(run, artifact_id)
-    for artifact in _indexed_artifacts(run):
-        if _is_results_archive_artifact(artifact):
-            return artifact
-    return None
+def _has_downloadable_results(run: dict[str, Any]) -> bool:
+    observability = run.get("observability") if isinstance(run.get("observability"), dict) else {}
+    outputs = observability.get("outputs") if isinstance(observability.get("outputs"), list) else []
+    return any(isinstance(artifact, dict) and str(artifact.get("path", "")).strip() for artifact in outputs)
 
 
 def _resolve_artifact(run: dict[str, Any], artifact_id: str) -> dict[str, Any]:
@@ -1241,10 +1223,6 @@ def _resolve_artifact(run: dict[str, Any], artifact_id: str) -> dict[str, Any]:
     )
 
 
-def _is_results_archive_artifact(artifact: dict[str, Any]) -> bool:
-    return Path(str(artifact.get("path", ""))).name == "results.zip"
-
-
 def _download_selected_artifact(
     *,
     run_id: str,
@@ -1424,9 +1402,7 @@ def _artifact_action_panel(run: dict[str, Any], artifact: dict[str, Any]) -> Pan
     workflow = str(run.get("workflow", ""))
     command_prefix = _foundry_command_prefix(workflow)
     artifact_id = str(artifact.get("id", ""))
-    if _is_results_archive_artifact(artifact):
-        command = f"{command_prefix} jobs download --id {run_id}"
-    elif artifact_id:
+    if artifact_id:
         command = f"{command_prefix} jobs download --id {run_id} --artifact-id {artifact_id}"
     else:
         command = f"{command_prefix} jobs download --id {run_id}"
@@ -1489,26 +1465,22 @@ def _foundry_queries_panel(request_data: dict[str, Any] | None) -> Panel | None:
 
 def _load_foundry_result_preview(run: dict[str, Any]) -> dict[str, Any] | None:
     run_id = str(run.get("id", ""))
-    archive_path = _foundry_results_archive_path(run)
     archive_result: dict[str, Any] | None = None
-    if archive_path:
+    if _has_downloadable_results(run):
         try:
-            archive_bytes = download_foundry_run_artifact(run_id, archive_path)
+            archive_bytes = download_foundry_run_archive(run_id)
             archive_result = _inspect_foundry_results_archive(archive_bytes)
         except CLIError:
             pass
 
-    # The mock model (and Foundry's execution path) writes meta/*.json as
-    # separate filesystem artifacts rather than packing them into results.zip.
-    # Fall back to loading those individual metadata artifacts when the zip
-    # contains no meta/ entries.
+    # Fall back to individual metadata artifacts when the Hub archive endpoint
+    # is unavailable or contains no meta/ entries.
     if archive_result is not None and not archive_result.get("metadata"):
         metadata = _load_metadata_artifacts(run_id, run)
         if metadata:
             archive_result["metadata"] = metadata
 
     if archive_result is None:
-        # No results.zip at all — try to build a minimal preview from loose artifacts.
         metadata = _load_metadata_artifacts(run_id, run)
         if metadata:
             archive_result = {"predictions": [], "metadata": metadata, "other_files": []}
@@ -1684,12 +1656,10 @@ def _foundry_result_guidance_panel(run: dict[str, Any], *, result_preview: dict[
     run_id = str(run.get("id", "")).strip()
     if not run_id:
         return None
-    archive_path = _foundry_results_archive_path(run)
-    if archive_path:
+    if _has_downloadable_results(run):
         table = Table(box=box.SIMPLE_HEAD, show_header=True, padding=(0, 1), expand=True)
         table.add_column("FIELD", style="bold", no_wrap=True)
         table.add_column("VALUE", overflow="fold")
-        table.add_row("Archive", archive_path)
         table.add_row("Download", f"apheris-foundry jobs download --id {run_id}")
         if result_preview:
             predictions = result_preview.get("predictions", [])
@@ -1702,8 +1672,8 @@ def _foundry_result_guidance_panel(run: dict[str, Any], *, result_preview: dict[
 
     if str(run.get("status", "")).lower() == "succeeded":
         message = (
-            "No published output files are present in this Hub response yet. "
-            "After deploying the updated Hub, rerun the workflow or fetch this run again."
+            "No output artifacts are present in this Hub response. "
+            "Use the artifact IDs above to download individual files when available."
         )
         return Panel(Text(message, style="dim"), title="Results", border_style="dim")
     return None
@@ -1994,3 +1964,37 @@ def _poll_until_terminal(run_id: str) -> dict[str, Any]:
         if status in _TERMINAL_STATUSES:
             return run
         time.sleep(_POLL_INTERVAL)
+
+
+def _exit_if_failed_run(run: dict[str, Any]) -> None:
+    if str(run.get("status", "")).lower() != "failed":
+        return
+    raise typer.Exit(code=_failed_run_exit_code(run))
+
+
+def _failed_run_exit_code(run: dict[str, Any]) -> int:
+    for value in _run_exit_code_candidates(run):
+        try:
+            code = int(str(value).strip())
+        except (TypeError, ValueError):
+            continue
+        if 0 < code < 256:
+            return code
+    return EXIT_INTERNAL
+
+
+def _run_exit_code_candidates(run: dict[str, Any]) -> Iterable[Any]:
+    yield run.get("exitCode")
+    observability = run.get("observability")
+    if not isinstance(observability, dict):
+        return
+    steps = observability.get("steps")
+    if not isinstance(steps, list):
+        return
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        status = str(step.get("status", "")).upper()
+        exit_code = str(step.get("exitCode", "")).strip()
+        if status in {"FAILED", "ERROR"} or exit_code not in {"", "0", "-"}:
+            yield step.get("exitCode")

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/src/apherisfold_cli/core/hub_requests.py

@@ -247,5 +247,10 @@ def download_foundry_run_artifact(run_id: str, path: str) -> bytes:
     )
 
 
+def download_foundry_run_archive(run_id: str) -> bytes:
+    encoded = urllib.parse.quote(run_id, safe="")
+    return _request_bytes(path=f"/api/v1/foundry/runs/{encoded}/archive", method="GET", task="foundry.runs.archive")
+
+
 def create_foundry_run(body: dict[str, Any]) -> dict[str, Any]:
     return _request_json(path="/api/v1/foundry/runs", method="POST", task="foundry.run", body=body)

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/src/apherisfold_cli/core/result_artifacts.py

@@ -62,6 +62,22 @@ def extract_results_archive(
         archive.extractall(output_dir)
         file_names = sorted(info.filename for info in archive.infolist() if not info.is_dir())
 
+    return summarize_result_files(
+        output_dir=output_dir,
+        file_names=file_names,
+        result_view=result_view,
+        task=task,
+    )
+
+
+def summarize_result_files(
+    *,
+    output_dir: Path,
+    file_names: list[str],
+    result_view: str,
+    task: str,
+) -> dict[str, Any]:
+    validate_result_view(result_view, task=task)
     metadata_entries: list[dict[str, Any]] = []
     metric_entries: list[dict[str, Any]] = []
     prediction_entries: list[dict[str, Any]] = []

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/src/apherisfold_cli/main.py

@@ -353,10 +353,10 @@ def workflows_run_cmd(
         if model_params is not None:
             params = _validate_foundry_model_params(workflow_id, params, model_params)
             params = {**(params or {}), "modelParams": json.dumps(model_params, separators=(",", ":"))}
-        elif weight:
+        elif weight or (params and "model" in params):
             # A weight identifies a model version only in the context of a
-            # model. For a one-model workflow we can make that selection
-            # explicit without burdening the user with --param model=... .
+            # model. An explicit model also needs a concrete default weight so
+            # Hub launches the same model artifact shown by workflow metadata.
             _, params = _resolve_foundry_model_selection(workflow_id, params)
     except typer.BadParameter as error:
         typer.echo(str(error), err=True)

apheris_foundry_cli-0.4.0/src/apherisfold_cli/version.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/tests/test_cli.py

@@ -19,12 +19,21 @@ from apherisfold_cli.main import app
 runner = CliRunner()
 
 
+def _make_foundry_archive(*entries: tuple[str, bytes]) -> bytes:
+    buffer = BytesIO()
+    with zipfile.ZipFile(buffer, "w") as archive:
+        for name, content in entries:
+            archive.writestr(name, content)
+    return buffer.getvalue()
+
+
 @pytest.fixture(autouse=True)
 def hub_api_fixture(monkeypatch):
     calls: dict[str, Any] = {
         "create_foundry_run": [],
         "get_foundry_run": [],
         "get_foundry_run_logs": [],
+        "download_foundry_run_archive": [],
         "download_foundry_run_artifact": [],
         "list_foundry_runs": [],
         "list_foundry_workflows": [],
@@ -217,6 +226,25 @@ def hub_api_fixture(monkeypatch):
             ).encode()
         return b"trace-bytes"
 
+    def fake_download_foundry_run_archive(run_id):
+        calls["download_foundry_run_archive"].append(run_id)
+        buffer = BytesIO()
+        with zipfile.ZipFile(buffer, "w") as archive:
+            archive.writestr(
+                "meta/mcl1_sample_1.json",
+                json.dumps(
+                    {
+                        "query_id": "mcl1",
+                        "sample_id": 1,
+                        "affinity_prediction": 6.8,
+                        "plddt": [94.9, 95.02],
+                    }
+                ),
+            )
+            archive.writestr("mcl1_sample_1_model.cif", "model-cif")
+            archive.writestr("errors/mcl1_sample_2.json", json.dumps({"error": "failed sample"}))
+        return buffer.getvalue()
+
     def fake_list_foundry_runs():
         calls["list_foundry_runs"].append(True)
         return {"runs": [fake_get_foundry_run("foundry_test_failed")]}
@@ -345,6 +373,9 @@ def hub_api_fixture(monkeypatch):
     monkeypatch.setattr(
         "apherisfold_cli.commands.foundry.download_foundry_run_artifact", fake_download_foundry_run_artifact
     )
+    monkeypatch.setattr(
+        "apherisfold_cli.commands.foundry.download_foundry_run_archive", fake_download_foundry_run_archive
+    )
     monkeypatch.setattr("apherisfold_cli.commands.foundry.list_foundry_runs", fake_list_foundry_runs)
     monkeypatch.setattr("apherisfold_cli.commands.foundry.list_foundry_workflows", fake_list_foundry_workflows)
     monkeypatch.setattr("apherisfold_cli.commands.foundry.get_foundry_workflow", fake_get_foundry_workflow)
@@ -513,17 +544,10 @@ def test_foundry_workflows_run_serializes_selected_weight(hub_api_fixture) -> No
     assert hub_api_fixture["create_foundry_run"][0]["params"] == {"model": "openfold3", "weight": "0.3.0"}
 
 
-def test_foundry_workflows_run_preserves_predict_request_filename(tmp_path: Path, hub_api_fixture) -> None:
-    request = tmp_path / "request-protein-ligand.json"
+def test_foundry_workflows_run_resolves_default_weight_for_selected_model(tmp_path: Path, hub_api_fixture) -> None:
+    request = tmp_path / "request-minimal.json"
     request.write_text('{"queries": []}', encoding="utf-8")
 
-    result = runner.invoke(app, ["workflows", "run", "--workflow", "predict", "--input", str(request)])
-
-    assert result.exit_code == 0
-    assert hub_api_fixture["create_foundry_run"][0]["inputs"] == {"request-protein-ligand.json": '{"queries": []}'}
-
-
-def test_foundry_workflows_run_rejects_model_params_outside_schema(hub_api_fixture) -> None:
     result = runner.invoke(
         app,
         [
@@ -531,13 +555,45 @@ def test_foundry_workflows_run_rejects_model_params_outside_schema(hub_api_fixtu
             "run",
             "--workflow",
             "predict",
-            "--model-params",
-            '{"seed":7}',
+            "--input",
+            str(request),
+            "--param",
+            "model=openfold3",
         ],
     )
 
-    assert result.exit_code != 0
-    assert "invalid --model-params" in result.stderr
+    assert result.exit_code == 0
+    body = hub_api_fixture["create_foundry_run"][0]
+    assert body["params"] == {"model": "openfold3", "weight": "0.0.0"}
+    assert body["inputs"] == {"request-minimal.json": '{"queries": []}'}
+
+
+def test_foundry_workflows_run_preserves_predict_request_filename(tmp_path: Path, hub_api_fixture) -> None:
+    request = tmp_path / "request-protein-ligand.json"
+    request.write_text('{"queries": []}', encoding="utf-8")
+
+    result = runner.invoke(app, ["workflows", "run", "--workflow", "predict", "--input", str(request)])
+
+    assert result.exit_code == 0
+    assert hub_api_fixture["create_foundry_run"][0]["inputs"] == {"request-protein-ligand.json": '{"queries": []}'}
+
+
+def test_foundry_workflows_run_rejects_model_params_outside_schema(hub_api_fixture) -> None:
+    for model_params in ['{"seed":7}', '{"diffusion_samples":2}']:
+        result = runner.invoke(
+            app,
+            [
+                "workflows",
+                "run",
+                "--workflow",
+                "predict",
+                "--model-params",
+                model_params,
+            ],
+        )
+
+        assert result.exit_code != 0
+        assert "invalid --model-params" in result.stderr
     assert hub_api_fixture["create_foundry_run"] == []
 
 
@@ -1171,6 +1227,8 @@ def test_foundry_download_result_extracts_archive(hub_api_fixture) -> None:
         extracted = list(Path(tmpdir).rglob("*"))
         assert any(f.suffix == ".cif" for f in extracted if f.is_file())
         assert (Path(tmpdir) / "result.json").exists()
+        assert hub_api_fixture["download_foundry_run_archive"] == ["foundry_test_001"]
+        assert not hub_api_fixture["download_foundry_run_artifact"]
 
 
 def test_foundry_download_result_json_output(hub_api_fixture) -> None:
@@ -1183,6 +1241,8 @@ def test_foundry_download_result_json_output(hub_api_fixture) -> None:
         payload = json.loads(result.stdout.strip())
         assert payload["kind"] == "foundry-predict-results"
         assert "results" in payload
+        assert hub_api_fixture["download_foundry_run_archive"] == ["foundry_test_001"]
+        assert not hub_api_fixture["download_foundry_run_artifact"]
 
 
 def test_foundry_download_result_show_flag(hub_api_fixture) -> None:
@@ -1214,6 +1274,72 @@ def test_foundry_download_result_files_result_view(hub_api_fixture) -> None:
         assert result.exit_code == 0, result.stdout
 
 
+def test_foundry_download_result_extracts_hub_archive_without_results_zip(monkeypatch) -> None:
+    run = {
+        "id": "foundry_loose_outputs",
+        "workflow": "predict",
+        "status": "succeeded",
+        "observability": {
+            "outputs": [
+                {
+                    "name": "Prediction metadata",
+                    "type": "metadata",
+                    "path": "output/output/meta/mcl1_sample_1.json",
+                    "sizeBytes": 120,
+                },
+                {
+                    "name": "Predicted structure",
+                    "type": "structure",
+                    "path": "output/output/mcl1_sample_1_model.cif",
+                    "sizeBytes": 9,
+                },
+                {
+                    "name": "Prediction metrics",
+                    "type": "metrics",
+                    "path": "output/output/metrics.json",
+                    "sizeBytes": 20,
+                },
+                {
+                    "name": "Prediction error",
+                    "type": "error",
+                    "path": "output/output/errors/mcl1_sample_2.json",
+                    "sizeBytes": 18,
+                },
+            ]
+        },
+    }
+    archive_calls: list[str] = []
+
+    monkeypatch.setattr("apherisfold_cli.commands.foundry.get_foundry_run", lambda run_id: run)
+    monkeypatch.setattr(
+        "apherisfold_cli.commands.foundry.download_foundry_run_archive",
+        lambda run_id: (
+            archive_calls.append(run_id)
+            or _make_foundry_archive(
+                ("meta/mcl1_sample_1.json", json.dumps({"query_id": "mcl1", "sample_id": 1}).encode()),
+                ("mcl1_sample_1_model.cif", b"model-cif"),
+                ("errors/mcl1_sample_2.json", b'{"error":"failed sample"}'),
+            )
+        ),
+    )
+    monkeypatch.setattr(
+        "apherisfold_cli.commands.foundry.download_foundry_run_artifact",
+        lambda run_id, path: pytest.fail("default download must not materialize loose artifacts"),
+    )
+
+    with TemporaryDirectory() as tmpdir:
+        result = runner.invoke(
+            app,
+            ["jobs", "download", "--id", run["id"], "--output", tmpdir],
+            env={"COLUMNS": "200"},
+        )
+
+        assert result.exit_code == 0, result.stdout
+        assert (Path(tmpdir) / "mcl1_sample_1_model.cif").read_text() == "model-cif"
+        assert (Path(tmpdir) / "errors" / "mcl1_sample_2.json").exists()
+    assert archive_calls == [run["id"]]
+
+
 # ---------------------------------------------------------------------------
 # Foundry commands — list
 # ---------------------------------------------------------------------------
@@ -1465,9 +1591,18 @@ def test_foundry_logs_follow_exits_on_terminal_status(monkeypatch) -> None:
     assert result.exit_code == 0
 
 
-def test_foundry_run_wait_mode(hub_api_fixture, monkeypatch) -> None:
-    """--wait blocks until run reaches terminal status."""
+def test_foundry_run_wait_mode_returns_failed_run_exit_code(hub_api_fixture, monkeypatch) -> None:
+    """--wait returns a non-zero exit code when the remote run fails."""
     monkeypatch.setattr("apherisfold_cli.commands.foundry.time.sleep", lambda _: None)
+    monkeypatch.setattr(
+        "apherisfold_cli.commands.foundry.get_foundry_run",
+        lambda run_id: {
+            "id": run_id,
+            "workflow": "fragment-analysis",
+            "status": "failed",
+            "observability": {"steps": [{"name": "SCORE", "status": "FAILED", "exitCode": "137"}]},
+        },
+    )
     with TemporaryDirectory() as tmpdir:
         input_path = Path(tmpdir) / "molecules.csv"
         input_path.write_text("smiles\nCCO\n")
@@ -1475,12 +1610,12 @@ def test_foundry_run_wait_mode(hub_api_fixture, monkeypatch) -> None:
             app,
             ["workflows", "run", "--workflow", "fragment-analysis", "--wait", "--input", str(input_path)],
         )
-    assert result.exit_code == 0
+    assert result.exit_code == 137
     assert "failed" in result.stdout.lower() or "finished" in result.stdout.lower()
 
 
-def test_foundry_run_wait_mode_json(hub_api_fixture, monkeypatch) -> None:
-    """--wait with --json outputs final run JSON."""
+def test_foundry_run_wait_mode_json_returns_failed_run_exit_code(hub_api_fixture, monkeypatch) -> None:
+    """--wait with --json outputs final run JSON and returns non-zero on failure."""
     monkeypatch.setattr("apherisfold_cli.commands.foundry.time.sleep", lambda _: None)
     with TemporaryDirectory() as tmpdir:
         input_path = Path(tmpdir) / "molecules.csv"
@@ -1498,11 +1633,34 @@ def test_foundry_run_wait_mode_json(hub_api_fixture, monkeypatch) -> None:
                 str(input_path),
             ],
         )
-    assert result.exit_code == 0
+    assert result.exit_code == 1
     # stdout has "Waiting for run..." prefix then JSON; check JSON is embedded
     assert '"id"' in result.stdout or '"status"' in result.stdout
 
 
+def test_foundry_run_wait_mode_succeeded_run_exits_zero(hub_api_fixture, monkeypatch) -> None:
+    """--wait keeps exit code 0 when the remote run succeeds."""
+    monkeypatch.setattr("apherisfold_cli.commands.foundry.time.sleep", lambda _: None)
+    monkeypatch.setattr(
+        "apherisfold_cli.commands.foundry.get_foundry_run",
+        lambda run_id: {
+            "id": run_id,
+            "workflow": "fragment-analysis",
+            "status": "succeeded",
+            "observability": {"steps": [{"name": "SCORE", "status": "COMPLETED", "exitCode": "0"}]},
+        },
+    )
+    with TemporaryDirectory() as tmpdir:
+        input_path = Path(tmpdir) / "molecules.csv"
+        input_path.write_text("smiles\nCCO\n")
+        result = runner.invoke(
+            app,
+            ["workflows", "run", "--workflow", "fragment-analysis", "--wait", "--input", str(input_path)],
+        )
+    assert result.exit_code == 0
+    assert "succeeded" in result.stdout.lower()
+
+
 def test_foundry_error_non_kubernetes_error(monkeypatch) -> None:
     """Error command for a run with a specific (non-generic) error message."""
     monkeypatch.setattr(
@@ -1674,6 +1832,10 @@ def test_foundry_download_result_non_archive_artifact(hub_api_fixture) -> None:
         )
         assert result.exit_code == 0
         assert (Path(tmpdir) / "metrics.json").exists()
+        assert not hub_api_fixture["download_foundry_run_archive"]
+        assert hub_api_fixture["download_foundry_run_artifact"] == [
+            {"run_id": "foundry_test_001", "path": "output/output/metrics.json"}
+        ]
 
 
 def test_foundry_download_result_non_archive_artifact_json(hub_api_fixture) -> None:
@@ -1697,6 +1859,10 @@ def test_foundry_download_result_non_archive_artifact_json(hub_api_fixture) -> N
         payload = json.loads(result.stdout.strip())
         assert payload["runId"] == "foundry_test_001"
         assert "output" in payload
+        assert not hub_api_fixture["download_foundry_run_archive"]
+        assert hub_api_fixture["download_foundry_run_artifact"] == [
+            {"run_id": "foundry_test_001", "path": "output/output/metrics.json"}
+        ]
 
 
 def test_foundry_download_result_unknown_artifact_id(hub_api_fixture) -> None:

{apheris_foundry_cli-0.3.0 → apheris_foundry_cli-0.4.0}/tests/test_hub_requests.py

@@ -13,6 +13,7 @@ from apherisfold_cli.core.errors import CLIError
 from apherisfold_cli.core.hub_requests import (
     _request_json,
     create_foundry_run,
+    download_foundry_run_archive,
     download_foundry_run_artifact,
     get_foundry_run,
     get_foundry_run_logs,
@@ -253,6 +254,21 @@ def test_download_foundry_run_artifact_returns_bytes(tmp_path: Path, monkeypatch
     assert data == b"binary artifact content"
 
 
+def test_download_foundry_run_archive_returns_bytes(tmp_path: Path, monkeypatch) -> None:
+    _save_refreshable_session(tmp_path, monkeypatch)
+    seen_url: list[str] = []
+
+    def fake_urlopen(request: urllib.request.Request, **_kwargs: object) -> FakeResponse:
+        seen_url.append(request.full_url)
+        assert request.method == "GET"
+        return FakeResponse(b"zip content")
+
+    monkeypatch.setattr("apherisfold_cli.core.hub_requests.urllib.request.urlopen", fake_urlopen)
+    data = download_foundry_run_archive("run/1")
+    assert data == b"zip content"
+    assert "/api/v1/foundry/runs/run%2F1/archive" in seen_url[0]
+
+
 # ---------------------------------------------------------------------------
 # Error handling
 # ---------------------------------------------------------------------------

apheris_foundry_cli-0.3.0/src/apherisfold_cli/version.py

@@ -1 +0,0 @@
-__version__ = "0.3.0"