genblaze-cli 0.3.0__tar.gz → 0.3.2__tar.gz

{genblaze_cli-0.3.0 → genblaze_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genblaze-cli
-Version: 0.3.0
+Version: 0.3.2
 Summary: CLI for genblaze manifest operations
 Project-URL: Homepage, https://github.com/backblaze-labs/genblaze
 Project-URL: Documentation, https://github.com/backblaze-labs/genblaze#readme
@@ -20,7 +20,7 @@ Classifier: Topic :: Multimedia
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0
-Requires-Dist: genblaze-core<0.4,>=0.2.0
+Requires-Dist: genblaze-core<0.4,>=0.3.4
 Provides-Extra: dev
 Requires-Dist: pillow>=10.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
@@ -31,11 +31,11 @@ Description-Content-Type: text/markdown
 
 **Command-line toolkit for inspecting, verifying, and indexing genblaze AI-generated-media provenance manifests.**
 
-`genblaze-cli` is the companion CLI for [genblaze](https://github.com/backblaze-labs/genblaze) — the Python SDK for generative AI pipelines across video, image, and audio. It lets anyone (not just Python developers) audit AI-generated media: extract the embedded provenance manifest from an MP4 / PNG / MP3, verify its SHA-256 hash, replay a run, or index manifests into Parquet for downstream analytics.
+`genblaze-cli` is the companion CLI for [genblaze](https://github.com/backblaze-labs/genblaze) — the Python SDK for generative AI pipelines across video, image, and audio. It lets anyone (not just Python developers) audit AI-generated media: extract the embedded provenance manifest from an MP4 / PNG / MP3, verify its manifest hash and output sha256 coverage, replay a run, or index manifests into Parquet for downstream analytics.
 
 ## Why genblaze-cli
 
-- **Audit AI-generated media in one command** — `genblaze verify video.mp4` confirms a file's manifest hash hasn't been tampered with.
+- **Audit AI-generated media in one command** — `genblaze verify video.mp4` confirms a file's manifest hash hasn't been tampered with and all output assets declare sha256.
 - **Works on any genblaze output** — PNG, JPEG, WebP, MP4, MP3, WAV with embedded manifests.
 - **Analytics-ready** — `genblaze index` emits partitioned Parquet tables (runs, steps, assets) for BI tools and data warehouses.
 - **Zero provider dependencies** — reads manifests; doesn't call any AI API.
@@ -57,7 +57,7 @@ genblaze --help
 genblaze extract video.mp4                # Extract embedded manifest → stdout (JSON)
 genblaze extract video.mp4 -o m.json      # …or to a file
 
-genblaze verify video.mp4                 # Verify the embedded manifest's SHA-256
+genblaze verify video.mp4                 # Verify manifest hash + output sha256 declarations
 genblaze verify manifest.json             # Or verify a standalone manifest file
 
 genblaze replay manifest.json             # Show what a replay would do (dry run)
@@ -65,7 +65,7 @@ genblaze replay manifest.json             # Show what a replay would do (dry run
 genblaze index manifest.json -o data/     # Index into partitioned Parquet tables
 ```
 
-Exit codes are non-zero on verification failure — safe to drop into CI pipelines, release checks, or content-moderation workflows.
+Exit codes are non-zero on verification failure — safe to drop into CI pipelines, release checks, or content-moderation workflows. The command does not fetch remote asset URLs; consumers that dereference `asset.url` must hash those bytes separately and compare them with the manifest's `asset.sha256`.
 
 ## Typical flow
 

{genblaze_cli-0.3.0 → genblaze_cli-0.3.2}/README.md

@@ -3,11 +3,11 @@
 
 **Command-line toolkit for inspecting, verifying, and indexing genblaze AI-generated-media provenance manifests.**
 
-`genblaze-cli` is the companion CLI for [genblaze](https://github.com/backblaze-labs/genblaze) — the Python SDK for generative AI pipelines across video, image, and audio. It lets anyone (not just Python developers) audit AI-generated media: extract the embedded provenance manifest from an MP4 / PNG / MP3, verify its SHA-256 hash, replay a run, or index manifests into Parquet for downstream analytics.
+`genblaze-cli` is the companion CLI for [genblaze](https://github.com/backblaze-labs/genblaze) — the Python SDK for generative AI pipelines across video, image, and audio. It lets anyone (not just Python developers) audit AI-generated media: extract the embedded provenance manifest from an MP4 / PNG / MP3, verify its manifest hash and output sha256 coverage, replay a run, or index manifests into Parquet for downstream analytics.
 
 ## Why genblaze-cli
 
-- **Audit AI-generated media in one command** — `genblaze verify video.mp4` confirms a file's manifest hash hasn't been tampered with.
+- **Audit AI-generated media in one command** — `genblaze verify video.mp4` confirms a file's manifest hash hasn't been tampered with and all output assets declare sha256.
 - **Works on any genblaze output** — PNG, JPEG, WebP, MP4, MP3, WAV with embedded manifests.
 - **Analytics-ready** — `genblaze index` emits partitioned Parquet tables (runs, steps, assets) for BI tools and data warehouses.
 - **Zero provider dependencies** — reads manifests; doesn't call any AI API.
@@ -29,7 +29,7 @@ genblaze --help
 genblaze extract video.mp4                # Extract embedded manifest → stdout (JSON)
 genblaze extract video.mp4 -o m.json      # …or to a file
 
-genblaze verify video.mp4                 # Verify the embedded manifest's SHA-256
+genblaze verify video.mp4                 # Verify manifest hash + output sha256 declarations
 genblaze verify manifest.json             # Or verify a standalone manifest file
 
 genblaze replay manifest.json             # Show what a replay would do (dry run)
@@ -37,7 +37,7 @@ genblaze replay manifest.json             # Show what a replay would do (dry run
 genblaze index manifest.json -o data/     # Index into partitioned Parquet tables
 ```
 
-Exit codes are non-zero on verification failure — safe to drop into CI pipelines, release checks, or content-moderation workflows.
+Exit codes are non-zero on verification failure — safe to drop into CI pipelines, release checks, or content-moderation workflows. The command does not fetch remote asset URLs; consumers that dereference `asset.url` must hash those bytes separately and compare them with the manifest's `asset.sha256`.
 
 ## Typical flow
 

genblaze_cli-0.3.2/genblaze_cli/commands/extract.py

@@ -0,0 +1,40 @@
+"""Extract command — print embedded manifest from a media file."""
+
+from pathlib import Path
+
+import click
+from genblaze_core.canonical.json import canonical_json
+from genblaze_core.exceptions import ManifestError
+from genblaze_core.models.manifest import Manifest
+
+from genblaze_cli.manifest_io import extract_manifest
+
+
+def _manifest_json_for_display(manifest: Manifest) -> str:
+    """Serialize for inspection without bypassing write-schema guards."""
+    try:
+        manifest.assert_writable_schema()
+    except ManifestError:
+        return canonical_json(manifest.model_dump(mode="python"))
+    return manifest.to_canonical_json()
+
+
+@click.command()
+@click.argument("file", type=click.Path(exists=True, path_type=Path))
+@click.option("--format", "fmt", type=click.Choice(["json", "summary"]), default="json")
+def extract(file: Path, fmt: str) -> None:
+    """Extract and display the genblaze manifest from a media file."""
+    try:
+        manifest = extract_manifest(file)
+        if fmt == "json":
+            click.echo(_manifest_json_for_display(manifest))
+        else:
+            report = manifest.verification_report()
+            click.echo(f"Run ID:    {manifest.run.run_id}")
+            click.echo(f"Steps:     {len(manifest.run.steps)}")
+            click.echo(f"Hash:      {manifest.canonical_hash}")
+            click.echo(f"Hash OK:   {report.hash_ok}")
+            click.echo(f"Output sha256: {len(report.unverified_sha256_ids)} missing or malformed")
+            click.echo(f"Verified:  {report.ok} (asset bytes were not fetched or compared)")
+    except Exception as exc:
+        raise click.ClickException(f"{type(exc).__name__}: {exc}") from exc

{genblaze_cli-0.3.0 → genblaze_cli-0.3.2}/genblaze_cli/commands/index.py

@@ -17,12 +17,12 @@ import click
 )
 def index(manifest_file: Path, output: Path) -> None:
     """Write manifest data to a Parquet sink for querying."""
-    from genblaze_core.models.manifest import Manifest
+    from genblaze_core.models.manifest import parse_manifest
     from genblaze_core.sinks.parquet import ParquetSink
 
     try:
         data = json.loads(manifest_file.read_text(encoding="utf-8"))
-        manifest = Manifest.model_validate(data)
+        manifest = parse_manifest(data)
     except Exception as exc:
         raise click.ClickException(f"Failed to load manifest: {exc}") from exc
 

{genblaze_cli-0.3.0 → genblaze_cli-0.3.2}/genblaze_cli/commands/replay.py

@@ -4,7 +4,7 @@ import json
 from pathlib import Path
 
 import click
-from genblaze_core.models.enums import PromptVisibility
+from genblaze_core.models.enums import PromptVisibility, RunStatus
 
 
 def _load_provider(provider_name: str, allowed: tuple[str, ...] | None):
@@ -99,7 +99,6 @@ def replay(
 ) -> None:
     """Re-execute a pipeline from a manifest JSON file."""
     from genblaze_core.models.manifest import parse_manifest
-    from genblaze_core.pipeline import Pipeline
 
     try:
         data = json.loads(manifest_file.read_text(encoding="utf-8"))
@@ -107,14 +106,25 @@ def replay(
     except Exception as exc:
         raise click.ClickException(f"Failed to load manifest: {exc}") from exc
 
-    # Verify manifest hash integrity
-    if not force and not manifest.verify():
+    # Verify manifest hash integrity before replay. Output sha256 coverage is
+    # reported separately because URL-only outputs can be metadata-valid but
+    # not sha256-covered.
+    report = manifest.verification_report()
+    if not force and not report.hash_ok:
         click.echo(
             "WARNING: Manifest hash does not match content. The file may have been modified.",
             err=True,
         )
         if not click.confirm("Continue anyway?"):
             raise click.Abort()
+    elif not force:
+        if report.unverified_sha256_ids:
+            click.echo(
+                "WARNING: Manifest hash matches, but output asset bytes are not "
+                f"bound for {len(report.unverified_sha256_ids)} asset(s) "
+                "missing or malformed sha256.",
+                err=True,
+            )
 
     run = manifest.run
     _print_summary(run, show_prompts=show_prompts)
@@ -153,6 +163,8 @@ def replay(
         click.echo("  Detected chain mode from manifest step inputs.", err=True)
 
     # Cache providers by name to avoid re-instantiating
+    from genblaze_core.pipeline import Pipeline
+
     providers: dict[str, object] = {}
     pipe = Pipeline(
         run.name,
@@ -202,10 +214,17 @@ def replay(
         )
 
     try:
-        result = pipe.run()
+        result = pipe.run(raise_on_failure=False)
         click.echo()
+        if result.run.status in {RunStatus.FAILED, RunStatus.CANCELLED}:
+            click.echo(f"Replay failed. New run ID: {result.run.run_id}", err=True)
+            click.echo(f"Hash: {result.manifest.canonical_hash}", err=True)
+            click.echo(f"Status: {result.run.status}", err=True)
+            raise click.exceptions.Exit(1)
         click.echo(f"Replay complete. New run ID: {result.run.run_id}")
         click.echo(f"Hash: {result.manifest.canonical_hash}")
         click.echo(f"Status: {result.run.status}")
+    except click.exceptions.Exit:
+        raise
     except Exception as exc:
         raise click.ClickException(f"Replay failed: {exc}") from exc

genblaze_cli-0.3.2/genblaze_cli/commands/verify.py

@@ -0,0 +1,44 @@
+"""Verify command — check manifest hash and output sha256 coverage."""
+
+from pathlib import Path
+
+import click
+
+from genblaze_cli.manifest_io import extract_manifest
+
+
+@click.command()
+@click.argument("file", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--hash-only",
+    is_flag=True,
+    help="Only verify canonical_hash; do not require output sha256 declarations.",
+)
+def verify(file: Path, hash_only: bool) -> None:
+    """Verify an embedded, sidecar, or standalone genblaze manifest."""
+    try:
+        manifest = extract_manifest(file)
+        report = manifest.verification_report()
+        if not report.hash_ok:
+            click.echo("FAIL: manifest hash mismatch.", err=True)
+            raise click.exceptions.Exit(1)
+        if hash_only:
+            click.echo("OK: manifest hash verified. Asset bytes were not fetched or compared.")
+            return
+        if report.unverified_sha256_ids:
+            click.echo(
+                f"FAIL: {len(report.unverified_sha256_ids)} output asset(s) "
+                "missing or malformed sha256.",
+                err=True,
+            )
+            raise click.exceptions.Exit(1)
+        click.echo(
+            "OK: manifest hash verified; all output assets declare sha256. "
+            "Asset bytes were not fetched or compared."
+        )
+    except click.exceptions.Exit:
+        raise
+    except Exception as exc:
+        # Prefix with exception type so "PermissionError: ..." and
+        # "EmbeddingError: ..." are distinguishable at a glance.
+        raise click.ClickException(f"{type(exc).__name__}: {exc}") from exc

genblaze_cli-0.3.2/genblaze_cli/manifest_io.py

@@ -0,0 +1,42 @@
+"""Shared CLI manifest loading helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from genblaze_core._utils import MAX_MANIFEST_BYTES
+from genblaze_core.exceptions import EmbeddingError
+from genblaze_core.media import get_handler, guess_mime
+from genblaze_core.media.sidecar import PointerSidecarError, SidecarHandler
+from genblaze_core.models.manifest import Manifest, parse_manifest
+
+
+def load_standalone_json_manifest(file: Path) -> Manifest:
+    size = file.stat().st_size
+    if size > MAX_MANIFEST_BYTES:
+        raise EmbeddingError(
+            f"Manifest JSON exceeds size limit: {size} > {MAX_MANIFEST_BYTES} bytes"
+        )
+    data = json.loads(file.read_text(encoding="utf-8"))
+    if "run" not in data and "manifest_uri" in data:
+        raise PointerSidecarError(
+            manifest_uri=data["manifest_uri"],
+            canonical_hash=data.get("canonical_hash", ""),
+        )
+    return parse_manifest(data)
+
+
+def extract_manifest(file: Path) -> Manifest:
+    """Extract a manifest from standalone JSON, media, or sidecar files."""
+    if file.suffix.lower() == ".json":
+        return load_standalone_json_manifest(file)
+
+    mime = guess_mime(file)
+    handler = get_handler(mime)
+    if handler is not None:
+        try:
+            return handler.extract(file)
+        except EmbeddingError:
+            pass
+    return SidecarHandler().extract(file)

{genblaze_cli-0.3.0 → genblaze_cli-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "genblaze-cli"
-version = "0.3.0"
+version = "0.3.2"
 description = "CLI for genblaze manifest operations"
 authors = [{name = "Jeronimo De Leon", email = "jdeleon@backblaze.com"}]
 readme = "README.md"
@@ -23,7 +23,7 @@ classifiers = [
 keywords = ["genblaze", "ai", "media", "manifest", "provenance", "c2pa-ready", "genai", "pipeline", "cli", "command-line"]
 
 dependencies = [
-    "genblaze-core>=0.2.0,<0.4",
+    "genblaze-core>=0.3.4,<0.4",
     "click>=8.0",
 ]
 
@@ -48,3 +48,8 @@ packages = ["genblaze_cli"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+
+[tool.deptry]
+# Treat the `dev` extra as dev-only tooling so deptry does not flag pytest
+# (and other test-only deps) as unused declared deps (DEP002).
+optional_dependencies_dev_groups = ["dev"]

genblaze_cli-0.3.2/tests/test_cli.py

@@ -0,0 +1,475 @@
+"""Tests for CLI commands."""
+
+from __future__ import annotations
+
+import json
+import tomllib
+from pathlib import Path
+
+from click.testing import CliRunner
+from genblaze_cli.main import cli
+from genblaze_core._utils import MAX_MANIFEST_BYTES
+from genblaze_core.builders import RunBuilder, StepBuilder
+from genblaze_core.canonical.json import canonical_json
+from genblaze_core.media.png import PngHandler
+from genblaze_core.models.asset import Asset
+from genblaze_core.models.enums import Modality, ProviderErrorCode, StepStatus
+from genblaze_core.models.manifest import Manifest
+from genblaze_core.testing import MockProvider
+from PIL import Image
+
+
+def _create_manifest_json(tmp_path: Path) -> Path:
+    """Create a manifest JSON file for testing."""
+    step = StepBuilder("test", "test-model").prompt("hello world").modality(Modality.IMAGE).build()
+    run = RunBuilder("cli-test").add_step(step).build()
+    manifest = Manifest.from_run(run)
+
+    manifest_path = tmp_path / "manifest.json"
+    manifest_path.write_text(manifest.to_canonical_json(), encoding="utf-8")
+    return manifest_path
+
+
+def _create_embedded_png(tmp_path: Path) -> Path:
+    """Create a PNG with an embedded manifest."""
+    step = StepBuilder("test", "test-model").prompt("hello").build()
+    run = RunBuilder("png-test").add_step(step).build()
+    manifest = Manifest.from_run(run)
+
+    png_path = tmp_path / "test.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    PngHandler().embed(png_path, manifest)
+    return png_path
+
+
+def _create_url_only_manifest(*, schema_version: str | None = None) -> Manifest:
+    """Create a hash-valid manifest whose output assets are not byte-bound."""
+    step = StepBuilder("test", "test-model").prompt("hello").build()
+    step.status = StepStatus.SUCCEEDED
+    step.assets = [Asset(url="https://cdn.example.com/output.png", media_type="image/png")]
+    run = RunBuilder("url-only").add_step(step).build()
+    if schema_version is None:
+        return Manifest.from_run(run)
+    manifest = Manifest(run=run, schema_version=schema_version)
+    manifest.compute_hash()
+    return manifest
+
+
+def test_extract_json(tmp_path: Path) -> None:
+    png = _create_embedded_png(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["extract", str(png)])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "canonical_hash" in data
+    assert "run" in data
+
+
+def test_extract_json_read_only_schema_is_inspectable(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest(schema_version="1.6")
+    png_path = tmp_path / "read-only-schema.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    png_path.with_suffix(png_path.suffix + ".genblaze.json").write_text(
+        canonical_json(manifest.model_dump(mode="python")),
+        encoding="utf-8",
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["extract", str(png_path)])
+
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["schema_version"] == "1.6"
+    assert data["canonical_hash"] == manifest.canonical_hash
+
+
+def test_extract_summary(tmp_path: Path) -> None:
+    png = _create_embedded_png(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["extract", "--format", "summary", str(png)])
+    assert result.exit_code == 0
+    assert "Run ID:" in result.output
+    assert "Hash OK:" in result.output
+    assert "Output sha256:" in result.output
+    assert "Verified:" in result.output
+
+
+def test_verify_ok(tmp_path: Path) -> None:
+    png = _create_embedded_png(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(png)])
+    assert result.exit_code == 0
+    assert "OK" in result.output
+    assert "asset integrity" not in result.output
+
+
+def test_verify_standalone_manifest_json(tmp_path: Path) -> None:
+    manifest_path = _create_manifest_json(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(manifest_path)])
+
+    assert result.exit_code == 0
+    assert "OK" in result.output
+
+
+def test_extract_standalone_manifest_json(tmp_path: Path) -> None:
+    manifest_path = _create_manifest_json(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["extract", str(manifest_path)])
+
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["canonical_hash"]
+
+
+def test_verify_standalone_manifest_json_case_insensitive_suffix(tmp_path: Path) -> None:
+    manifest_path = _create_manifest_json(tmp_path)
+    upper_path = tmp_path / "MANIFEST.JSON"
+    upper_path.write_text(manifest_path.read_text(encoding="utf-8"), encoding="utf-8")
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(upper_path)])
+
+    assert result.exit_code == 0
+    assert "OK" in result.output
+
+
+def test_verify_direct_sidecar_json(tmp_path: Path) -> None:
+    manifest_path = _create_manifest_json(tmp_path)
+    sidecar_path = tmp_path / "image.png.genblaze.json"
+    sidecar_path.write_text(manifest_path.read_text(encoding="utf-8"), encoding="utf-8")
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(sidecar_path)])
+
+    assert result.exit_code == 0
+    assert "OK" in result.output
+
+
+def test_verify_direct_pointer_sidecar_json_has_actionable_error(tmp_path: Path) -> None:
+    sidecar_path = tmp_path / "image.png.genblaze.json"
+    sidecar_path.write_text(
+        json.dumps(
+            {
+                "schema_version": "1.5",
+                "canonical_hash": "a" * 64,
+                "manifest_uri": "https://cdn.example.com/manifest.json",
+            }
+        ),
+        encoding="utf-8",
+    )
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(sidecar_path)])
+    combined = result.output + getattr(result, "stderr", "")
+
+    assert result.exit_code != 0
+    assert "Sidecar is a pointer" in combined
+    assert "Fetch the full manifest" in combined
+
+
+def test_verify_standalone_manifest_json_size_cap(tmp_path: Path) -> None:
+    manifest_path = tmp_path / "manifest.json"
+    with manifest_path.open("wb") as fh:
+        fh.truncate(MAX_MANIFEST_BYTES + 1)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(manifest_path)])
+    combined = result.output + getattr(result, "stderr", "")
+
+    assert result.exit_code != 0
+    assert "exceeds size limit" in combined
+
+
+def test_verify_ok_does_not_claim_remote_bytes_were_hashed(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest()
+    manifest.run.steps[0].assets[0].sha256 = "f" * 64
+    manifest.compute_hash()
+    png_path = tmp_path / "declared-sha.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    PngHandler().embed(png_path, manifest)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(png_path)])
+
+    assert result.exit_code == 0
+    assert "all output assets declare sha256" in result.output
+    assert "Asset bytes were not fetched or compared" in result.output
+    assert "asset integrity" not in result.output
+
+
+def test_verify_distinguishes_unverified_assets(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest()
+    png_path = tmp_path / "url-only.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    PngHandler().embed(png_path, manifest)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(png_path)])
+    combined = result.output + getattr(result, "stderr", "")
+    assert result.exit_code != 0
+    assert "1 output asset(s) missing or malformed sha256" in combined
+    assert "hash mismatch" not in combined
+
+
+def test_verify_hash_only_preserves_legacy_url_only_exit_code(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest()
+    png_path = tmp_path / "url-only.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    PngHandler().embed(png_path, manifest)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", "--hash-only", str(png_path)])
+
+    assert result.exit_code == 0
+    assert "manifest hash verified" in result.output
+    assert "Asset bytes were not fetched or compared" in result.output
+
+
+def test_verify_rejects_malformed_output_sha256(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest()
+    object.__setattr__(manifest.run.steps[0].assets[0], "sha256", "not-a-sha")
+    manifest.compute_hash()
+    png_path = tmp_path / "bad-sha.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    png_path.with_suffix(png_path.suffix + ".genblaze.json").write_text(
+        manifest.to_canonical_json(),
+        encoding="utf-8",
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(png_path)])
+    combined = result.output + getattr(result, "stderr", "")
+
+    assert result.exit_code != 0
+    assert "1 output asset(s) missing or malformed sha256" in combined
+
+
+def test_verify_reports_legacy_unverified_assets(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest(schema_version="1.5")
+    png_path = tmp_path / "legacy-url-only.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    PngHandler().embed(png_path, manifest)
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(png_path)])
+    combined = result.output + getattr(result, "stderr", "")
+    assert result.exit_code != 0
+    assert "1 output asset(s) missing or malformed sha256" in combined
+    assert "hash mismatch" not in combined
+
+
+def test_extract_summary_and_verify_agree_on_legacy_unverified_assets(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest(schema_version="1.5")
+    png_path = tmp_path / "legacy-url-only.png"
+    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
+    PngHandler().embed(png_path, manifest)
+
+    runner = CliRunner()
+    extract_result = runner.invoke(cli, ["extract", "--format", "summary", str(png_path)])
+    verify_result = runner.invoke(cli, ["verify", str(png_path)])
+
+    assert extract_result.exit_code == 0
+    assert "Hash OK:   True" in extract_result.output
+    assert "Output sha256: 1 missing or malformed" in extract_result.output
+    assert "Verified:  False" in extract_result.output
+    assert verify_result.exit_code != 0
+    assert not manifest.verify()
+
+
+def test_verify_no_manifest(tmp_path: Path) -> None:
+    png = tmp_path / "bare.png"
+    Image.new("RGBA", (1, 1)).save(png)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["verify", str(png)])
+    assert result.exit_code != 0
+
+
+def test_replay_dry_run(tmp_path: Path) -> None:
+    manifest_path = _create_manifest_json(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["replay", str(manifest_path)])
+    assert result.exit_code == 0
+    assert "Dry run" in result.output
+    assert "Step 1:" in result.output
+
+
+def test_replay_warns_on_unverified_assets_without_abort(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest()
+    manifest_path = tmp_path / "url-only.json"
+    manifest_path.write_text(manifest.to_canonical_json(), encoding="utf-8")
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["replay", str(manifest_path)])
+    combined = result.output + getattr(result, "stderr", "")
+    assert result.exit_code == 0
+    assert "output asset bytes are not bound" in combined
+    assert "Dry run" in result.output
+
+
+def test_replay_warns_on_legacy_unverified_assets(tmp_path: Path) -> None:
+    manifest = _create_url_only_manifest(schema_version="1.5")
+    manifest_path = tmp_path / "legacy-url-only.json"
+    manifest_path.write_text(manifest.to_canonical_json(), encoding="utf-8")
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["replay", str(manifest_path)])
+    combined = result.output + getattr(result, "stderr", "")
+    assert result.exit_code == 0
+    assert "output asset bytes are not bound" in combined
+    assert "Dry run" in result.output
+
+
+def test_cli_core_dependency_floor_matches_local_core() -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    cli_project = tomllib.loads((repo_root / "cli/pyproject.toml").read_text())
+    core_project = tomllib.loads((repo_root / "libs/core/pyproject.toml").read_text())
+
+    expected = f"genblaze-core>={core_project['project']['version']},<0.4"
+    assert expected in cli_project["project"]["dependencies"]
+
+
+def test_umbrella_core_dependency_floor_matches_local_core() -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    meta_project = tomllib.loads((repo_root / "libs/meta/pyproject.toml").read_text())
+    core_project = tomllib.loads((repo_root / "libs/core/pyproject.toml").read_text())
+
+    expected = f"genblaze-core>={core_project['project']['version']},<0.4"
+    assert expected in meta_project["project"]["dependencies"]
+
+
+def test_umbrella_s3_dependency_floor_matches_local_s3() -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    meta_project = tomllib.loads((repo_root / "libs/meta/pyproject.toml").read_text())
+    s3_project = tomllib.loads((repo_root / "libs/connectors/s3/pyproject.toml").read_text())
+
+    expected = f"genblaze-s3>={s3_project['project']['version']},<0.4"
+    assert expected in meta_project["project"]["dependencies"]
+
+
+def test_umbrella_connector_extra_floors_match_local_versions() -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    meta_project = tomllib.loads((repo_root / "libs/meta/pyproject.toml").read_text())
+    connector_dirs = [
+        "decart",
+        "elevenlabs",
+        "gmicloud",
+        "google",
+        "hume",
+        "langsmith",
+        "lmnt",
+        "luma",
+        "nvidia",
+        "openai",
+        "replicate",
+        "runway",
+        "stability-audio",
+    ]
+    requirements = [
+        requirement
+        for values in meta_project["project"]["optional-dependencies"].values()
+        for requirement in values
+    ]
+
+    for connector_dir in connector_dirs:
+        project = tomllib.loads(
+            (repo_root / f"libs/connectors/{connector_dir}/pyproject.toml").read_text()
+        )
+        package = project["project"]["name"]
+        expected = f"{package}>={project['project']['version']},<0.4"
+        matching = [requirement for requirement in requirements if requirement.startswith(package)]
+        assert matching
+        assert set(matching) == {expected}
+
+
+def test_replay_redacts_prompts_by_default(tmp_path: Path) -> None:
+    """Dry-run summary must redact prompts unless --show-prompts is passed."""
+    manifest_path = _create_manifest_json(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["replay", str(manifest_path)])
+    assert result.exit_code == 0
+    assert "hello world" not in result.output
+    assert "[redacted" in result.output
+
+
+def test_replay_shows_public_prompts_with_flag(tmp_path: Path) -> None:
+    """--show-prompts reveals public-visibility prompts."""
+    manifest_path = _create_manifest_json(tmp_path)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["replay", str(manifest_path), "--show-prompts"])
+    assert result.exit_code == 0
+    assert "hello world" in result.output
+
+
+def test_replay_redacts_private_prompts_even_with_flag(tmp_path: Path) -> None:
+    """--show-prompts must NOT reveal non-public prompts."""
+    from genblaze_core.models.enums import PromptVisibility
+
+    step = (
+        StepBuilder("test", "test-model")
+        .prompt("secret prompt content")
+        .modality(Modality.IMAGE)
+        .build()
+    )
+    step.prompt_visibility = PromptVisibility.PRIVATE
+    run = RunBuilder("cli-test").add_step(step).build()
+    manifest = Manifest.from_run(run)
+    manifest_path = tmp_path / "private.json"
+    manifest_path.write_text(manifest.to_canonical_json(), encoding="utf-8")
+
+    runner = CliRunner()
+    result = runner.invoke(cli, ["replay", str(manifest_path), "--show-prompts"])
+    assert result.exit_code == 0
+    assert "secret prompt content" not in result.output
+    assert "[redacted" in result.output
+
+
+def test_replay_aborts_when_no_allowlist_and_declined(tmp_path: Path) -> None:
+    """Non-dry-run replay without --allow-provider must prompt for confirmation
+    and abort on 'no'."""
+    manifest_path = _create_manifest_json(tmp_path)
+    runner = CliRunner()
+    # Respond "n" to the per-provider confirmation prompt
+    result = runner.invoke(cli, ["replay", str(manifest_path), "--no-dry-run"], input="n\n")
+    assert result.exit_code != 0
+    assert "Aborted" in result.output or "Execute with provider" in result.output
+
+
+def test_replay_no_dry_run_exits_nonzero_when_run_fails(tmp_path: Path, monkeypatch) -> None:
+    """A replayed failed run must not look successful to automation."""
+
+    class FailingReplayProvider(MockProvider):
+        def __init__(self) -> None:
+            super().__init__(
+                name="test",
+                should_fail=True,
+                error_code=ProviderErrorCode.AUTH_FAILURE,
+                error_message="missing credentials",
+            )
+
+    import genblaze_core.providers.registry as provider_registry
+
+    monkeypatch.setattr(
+        provider_registry,
+        "discover_providers",
+        lambda: {"test": FailingReplayProvider},
+    )
+    manifest_path = _create_manifest_json(tmp_path)
+    runner = CliRunner()
+
+    result = runner.invoke(
+        cli,
+        ["replay", str(manifest_path), "--no-dry-run", "--allow-provider", "test"],
+    )
+
+    assert result.exit_code != 0
+    assert "Replay failed" in result.stderr
+    assert "Replay failed" not in result.stdout
+    assert "Replay complete" not in result.stdout
+
+
+def test_index(tmp_path: Path) -> None:
+    manifest_path = _create_manifest_json(tmp_path)
+    out_dir = tmp_path / "index_out"
+    runner = CliRunner()
+    result = runner.invoke(cli, ["index", str(manifest_path), "-o", str(out_dir)])
+    assert result.exit_code == 0
+    assert "Indexed" in result.output
+    parquet_files = list(out_dir.rglob("*.parquet"))
+    assert len(parquet_files) > 0

genblaze_cli-0.3.0/genblaze_cli/commands/extract.py

@@ -1,40 +0,0 @@
-"""Extract command — print embedded manifest from a media file."""
-
-from pathlib import Path
-
-import click
-from genblaze_core.exceptions import EmbeddingError
-from genblaze_core.media import get_handler, guess_mime
-from genblaze_core.media.sidecar import SidecarHandler
-
-
-def _extract_manifest(file: Path):
-    """Try format-specific handler first, then sidecar fallback."""
-    mime = guess_mime(file)
-    handler = get_handler(mime)
-    if handler is not None:
-        try:
-            return handler.extract(file)
-        except EmbeddingError:
-            pass  # Expected: no manifest in this format, try sidecar
-    # Try sidecar fallback
-    sidecar = SidecarHandler()
-    return sidecar.extract(file)
-
-
-@click.command()
-@click.argument("file", type=click.Path(exists=True, path_type=Path))
-@click.option("--format", "fmt", type=click.Choice(["json", "summary"]), default="json")
-def extract(file: Path, fmt: str) -> None:
-    """Extract and display the genblaze manifest from a media file."""
-    try:
-        manifest = _extract_manifest(file)
-        if fmt == "json":
-            click.echo(manifest.to_canonical_json())
-        else:
-            click.echo(f"Run ID:    {manifest.run.run_id}")
-            click.echo(f"Steps:     {len(manifest.run.steps)}")
-            click.echo(f"Hash:      {manifest.canonical_hash}")
-            click.echo(f"Verified:  {manifest.verify()}")
-    except Exception as exc:
-        raise click.ClickException(f"{type(exc).__name__}: {exc}") from exc

genblaze_cli-0.3.0/genblaze_cli/commands/verify.py

@@ -1,41 +0,0 @@
-"""Verify command — check manifest hash integrity."""
-
-from pathlib import Path
-
-import click
-from genblaze_core.exceptions import EmbeddingError
-from genblaze_core.media import get_handler, guess_mime
-from genblaze_core.media.sidecar import SidecarHandler
-
-
-def _verify_manifest(file: Path) -> bool:
-    """Extract and verify manifest, trying format-specific handler then sidecar."""
-    mime = guess_mime(file)
-    handler = get_handler(mime)
-    if handler is not None:
-        try:
-            return handler.verify(file)
-        except EmbeddingError:
-            pass  # Expected: no manifest in this format, try sidecar
-    # Try sidecar fallback
-    sidecar = SidecarHandler()
-    return sidecar.verify(file)
-
-
-@click.command()
-@click.argument("file", type=click.Path(exists=True, path_type=Path))
-def verify(file: Path) -> None:
-    """Verify the integrity of a genblaze manifest in a media file."""
-    try:
-        valid = _verify_manifest(file)
-        if valid:
-            click.echo("OK — manifest hash verified.")
-        else:
-            click.echo("FAIL — manifest hash mismatch.", err=True)
-            raise click.exceptions.Exit(1)
-    except click.exceptions.Exit:
-        raise
-    except Exception as exc:
-        # Prefix with exception type so "PermissionError: ..." and
-        # "EmbeddingError: ..." are distinguishable at a glance.
-        raise click.ClickException(f"{type(exc).__name__}: {exc}") from exc

genblaze_cli-0.3.0/tests/test_cli.py

@@ -1,145 +0,0 @@
-"""Tests for CLI commands."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-from click.testing import CliRunner
-from genblaze_cli.main import cli
-from genblaze_core.builders import RunBuilder, StepBuilder
-from genblaze_core.media.png import PngHandler
-from genblaze_core.models.enums import Modality
-from genblaze_core.models.manifest import Manifest
-from PIL import Image
-
-
-def _create_manifest_json(tmp_path: Path) -> Path:
-    """Create a manifest JSON file for testing."""
-    step = StepBuilder("test", "test-model").prompt("hello world").modality(Modality.IMAGE).build()
-    run = RunBuilder("cli-test").add_step(step).build()
-    manifest = Manifest.from_run(run)
-
-    manifest_path = tmp_path / "manifest.json"
-    manifest_path.write_text(manifest.to_canonical_json(), encoding="utf-8")
-    return manifest_path
-
-
-def _create_embedded_png(tmp_path: Path) -> Path:
-    """Create a PNG with an embedded manifest."""
-    step = StepBuilder("test", "test-model").prompt("hello").build()
-    run = RunBuilder("png-test").add_step(step).build()
-    manifest = Manifest.from_run(run)
-
-    png_path = tmp_path / "test.png"
-    Image.new("RGBA", (1, 1), (255, 0, 0, 255)).save(png_path)
-    PngHandler().embed(png_path, manifest)
-    return png_path
-
-
-def test_extract_json(tmp_path: Path) -> None:
-    png = _create_embedded_png(tmp_path)
-    runner = CliRunner()
-    result = runner.invoke(cli, ["extract", str(png)])
-    assert result.exit_code == 0
-    data = json.loads(result.output)
-    assert "canonical_hash" in data
-    assert "run" in data
-
-
-def test_extract_summary(tmp_path: Path) -> None:
-    png = _create_embedded_png(tmp_path)
-    runner = CliRunner()
-    result = runner.invoke(cli, ["extract", "--format", "summary", str(png)])
-    assert result.exit_code == 0
-    assert "Run ID:" in result.output
-    assert "Verified:" in result.output
-
-
-def test_verify_ok(tmp_path: Path) -> None:
-    png = _create_embedded_png(tmp_path)
-    runner = CliRunner()
-    result = runner.invoke(cli, ["verify", str(png)])
-    assert result.exit_code == 0
-    assert "OK" in result.output
-
-
-def test_verify_no_manifest(tmp_path: Path) -> None:
-    png = tmp_path / "bare.png"
-    Image.new("RGBA", (1, 1)).save(png)
-    runner = CliRunner()
-    result = runner.invoke(cli, ["verify", str(png)])
-    assert result.exit_code != 0
-
-
-def test_replay_dry_run(tmp_path: Path) -> None:
-    manifest_path = _create_manifest_json(tmp_path)
-    runner = CliRunner()
-    result = runner.invoke(cli, ["replay", str(manifest_path)])
-    assert result.exit_code == 0
-    assert "Dry run" in result.output
-    assert "Step 1:" in result.output
-
-
-def test_replay_redacts_prompts_by_default(tmp_path: Path) -> None:
-    """Dry-run summary must redact prompts unless --show-prompts is passed."""
-    manifest_path = _create_manifest_json(tmp_path)
-    runner = CliRunner()
-    result = runner.invoke(cli, ["replay", str(manifest_path)])
-    assert result.exit_code == 0
-    assert "hello world" not in result.output
-    assert "[redacted" in result.output
-
-
-def test_replay_shows_public_prompts_with_flag(tmp_path: Path) -> None:
-    """--show-prompts reveals public-visibility prompts."""
-    manifest_path = _create_manifest_json(tmp_path)
-    runner = CliRunner()
-    result = runner.invoke(cli, ["replay", str(manifest_path), "--show-prompts"])
-    assert result.exit_code == 0
-    assert "hello world" in result.output
-
-
-def test_replay_redacts_private_prompts_even_with_flag(tmp_path: Path) -> None:
-    """--show-prompts must NOT reveal non-public prompts."""
-    from genblaze_core.models.enums import PromptVisibility
-
-    step = (
-        StepBuilder("test", "test-model")
-        .prompt("secret prompt content")
-        .modality(Modality.IMAGE)
-        .build()
-    )
-    step.prompt_visibility = PromptVisibility.PRIVATE
-    run = RunBuilder("cli-test").add_step(step).build()
-    manifest = Manifest.from_run(run)
-    manifest_path = tmp_path / "private.json"
-    manifest_path.write_text(manifest.to_canonical_json(), encoding="utf-8")
-
-    runner = CliRunner()
-    result = runner.invoke(cli, ["replay", str(manifest_path), "--show-prompts"])
-    assert result.exit_code == 0
-    assert "secret prompt content" not in result.output
-    assert "[redacted" in result.output
-
-
-def test_replay_aborts_when_no_allowlist_and_declined(tmp_path: Path) -> None:
-    """Non-dry-run replay without --allow-provider must prompt for confirmation
-    and abort on 'no'."""
-    manifest_path = _create_manifest_json(tmp_path)
-    runner = CliRunner()
-    # Respond "n" to the per-provider confirmation prompt
-    result = runner.invoke(cli, ["replay", str(manifest_path), "--no-dry-run"], input="n\n")
-    assert result.exit_code != 0
-    assert "Aborted" in result.output or "Execute with provider" in result.output
-
-
-def test_index(tmp_path: Path) -> None:
-    manifest_path = _create_manifest_json(tmp_path)
-    out_dir = tmp_path / "index_out"
-    runner = CliRunner()
-    result = runner.invoke(cli, ["index", str(manifest_path), "-o", str(out_dir)])
-    assert result.exit_code == 0
-    assert "Indexed" in result.output
-    parquet_files = list(out_dir.rglob("*.parquet"))
-    assert len(parquet_files) > 0