genblaze-cli 0.2.0__tar.gz

genblaze_cli-0.2.0/.gitignore

@@ -0,0 +1,76 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+*.egg
+wheels/
+/MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# IDE / editors
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.project
+.settings/
+
+# Testing / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+*.cover
+
+# Type checking
+.mypy_cache/
+.pytype/
+.pyre/
+
+# Linting
+.ruff_cache/
+
+# OS files
+.DS_Store
+Thumbs.db
+ehthumbs.db
+
+# Environment / secrets
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+credentials.json
+
+# Jupyter
+.ipynb_checkpoints/
+
+# MkDocs build output
+site/
+
+# Claude Code — local/ephemeral
+.claude/settings.local.json
+.claude/worktrees/
+CLAUDE.local.md
+
+# Hypothesis test cache
+.hypothesis/
+
+# Temp files
+*.tmp
+*.bak
+*.log

genblaze_cli-0.2.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: genblaze-cli
+Version: 0.2.0
+Summary: CLI for genblaze manifest operations
+Project-URL: Homepage, https://github.com/backblaze-labs/genblaze
+Project-URL: Repository, https://github.com/backblaze-labs/genblaze
+Project-URL: Changelog, https://github.com/backblaze-labs/genblaze/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/backblaze-labs/genblaze/issues
+Author-email: Jeronimo De Leon <jdeleon@backblaze.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: genblaze-core<0.3,>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pillow>=10.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<!-- last_verified: 2026-04-22 -->
+# genblaze-cli
+
+**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.
+
+## 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.
+- **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.
+- **Shell-friendly** — non-zero exit codes on verification failure, pipeable JSON output.
+
+## Install
+
+```bash
+pip install genblaze-cli
+```
+
+Installs the `genblaze` console script.
+
+## Usage
+
+```bash
+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 manifest.json             # Or verify a standalone manifest file
+
+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.
+
+## Typical flow
+
+```bash
+# 1. Someone ships you an AI-generated video
+genblaze extract delivered-ad.mp4 -o manifest.json
+
+# 2. Confirm it hasn't been tampered with
+genblaze verify delivered-ad.mp4
+
+# 3. Index into your analytics warehouse
+genblaze index manifest.json -o s3://analytics/genblaze/
+```
+
+## Documentation
+
+- **Main repo**: https://github.com/backblaze-labs/genblaze
+- **CLI reference**: https://github.com/backblaze-labs/genblaze/tree/main/cli
+
+## Related packages
+
+- [`genblaze-core`](https://pypi.org/project/genblaze-core/) — the pipeline SDK that produces these manifests
+- [`genblaze-s3`](https://pypi.org/project/genblaze-s3/) — durable storage on [Backblaze B2](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze), AWS S3, Cloudflare R2, MinIO
+
+## License
+
+MIT

genblaze_cli-0.2.0/README.md

@@ -0,0 +1,67 @@
+<!-- last_verified: 2026-04-22 -->
+# genblaze-cli
+
+**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.
+
+## 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.
+- **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.
+- **Shell-friendly** — non-zero exit codes on verification failure, pipeable JSON output.
+
+## Install
+
+```bash
+pip install genblaze-cli
+```
+
+Installs the `genblaze` console script.
+
+## Usage
+
+```bash
+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 manifest.json             # Or verify a standalone manifest file
+
+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.
+
+## Typical flow
+
+```bash
+# 1. Someone ships you an AI-generated video
+genblaze extract delivered-ad.mp4 -o manifest.json
+
+# 2. Confirm it hasn't been tampered with
+genblaze verify delivered-ad.mp4
+
+# 3. Index into your analytics warehouse
+genblaze index manifest.json -o s3://analytics/genblaze/
+```
+
+## Documentation
+
+- **Main repo**: https://github.com/backblaze-labs/genblaze
+- **CLI reference**: https://github.com/backblaze-labs/genblaze/tree/main/cli
+
+## Related packages
+
+- [`genblaze-core`](https://pypi.org/project/genblaze-core/) — the pipeline SDK that produces these manifests
+- [`genblaze-s3`](https://pypi.org/project/genblaze-s3/) — durable storage on [Backblaze B2](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze), AWS S3, Cloudflare R2, MinIO
+
+## License
+
+MIT

genblaze_cli-0.2.0/genblaze_cli/__init__.py

@@ -0,0 +1 @@
+"""genblaze CLI."""

genblaze_cli-0.2.0/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.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.2.0/genblaze_cli/commands/index.py

@@ -0,0 +1,34 @@
+"""Index command — write manifest data to a Parquet sink."""
+
+import json
+from pathlib import Path
+
+import click
+
+
+@click.command()
+@click.argument("manifest_file", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(path_type=Path),
+    default="./genblaze_index",
+    help="Base directory for Parquet output.",
+)
+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.sinks.parquet import ParquetSink
+
+    try:
+        data = json.loads(manifest_file.read_text(encoding="utf-8"))
+        manifest = Manifest.model_validate(data)
+    except Exception as exc:
+        raise click.ClickException(f"Failed to load manifest: {exc}") from exc
+
+    try:
+        sink = ParquetSink(output)
+        sink.write_run(manifest.run, manifest)
+        click.echo(f"Indexed run {manifest.run.run_id} to {output}")
+    except Exception as exc:
+        raise click.ClickException(f"Failed to write Parquet: {exc}") from exc

genblaze_cli-0.2.0/genblaze_cli/commands/replay.py

@@ -0,0 +1,211 @@
+"""Replay command — re-execute a pipeline from a manifest file."""
+
+import json
+from pathlib import Path
+
+import click
+from genblaze_core.models.enums import PromptVisibility
+
+
+def _load_provider(provider_name: str, allowed: tuple[str, ...] | None):
+    """Load a provider by name using entry point discovery.
+
+    If allowed is set, reject providers not in the allowlist.
+    """
+    if allowed and provider_name not in allowed:
+        raise click.ClickException(
+            f"Provider '{provider_name}' not in allowlist: {', '.join(allowed)}"
+        )
+    from genblaze_core.providers.registry import discover_providers
+
+    registry = discover_providers()
+    cls = registry.get(provider_name)
+    if cls is None:
+        available = ", ".join(sorted(registry.keys())) or "(none installed)"
+        raise click.ClickException(
+            f"Unknown provider '{provider_name}'. Installed providers: {available}"
+        )
+    click.echo(f"  Loading provider: {provider_name}", err=True)
+    return cls()
+
+
+def _detect_chain_mode(run) -> bool:
+    """Detect if the original pipeline used chain mode by checking step inputs.
+
+    If any step has _input_from metadata, this is a fan-in pipeline (not chain).
+    Otherwise, if every non-first step has inputs, it was likely chain mode.
+    """
+    has_input_from = any(step.metadata.get("_input_from") is not None for step in run.steps)
+    if has_input_from:
+        return False
+    non_first = run.steps[1:]
+    return bool(non_first) and all(len(step.inputs) > 0 for step in non_first)
+
+
+def _print_summary(run, *, show_prompts: bool) -> None:
+    """Print manifest run summary.
+
+    Prompts are only shown when ``show_prompts`` is True AND the step's
+    prompt_visibility is PUBLIC. Non-public prompts are redacted to avoid
+    leaking private content to terminals/CI logs when replaying manifests
+    pulled from shared storage.
+    """
+    click.echo(f"Run:    {run.run_id}")
+    click.echo(f"Name:   {run.name or '(unnamed)'}")
+    click.echo(f"Steps:  {len(run.steps)}")
+    click.echo()
+
+    for i, step in enumerate(run.steps, 1):
+        click.echo(f"  Step {i}: {step.provider}/{step.model}")
+        click.echo(f"    Type:     {step.step_type}")
+        if show_prompts and step.prompt_visibility == PromptVisibility.PUBLIC:
+            click.echo(f"    Prompt:   {step.prompt or '(none)'}")
+        else:
+            click.echo(
+                f"    Prompt:   [redacted — visibility={step.prompt_visibility};"
+                " pass --show-prompts to reveal public prompts]"
+            )
+        click.echo(f"    Modality: {step.modality}")
+        if step.params:
+            click.echo(f"    Params:   {step.params}")
+
+
+# Fields that cannot be faithfully replayed (logged as warnings)
+_UNREPLAYABLE_FIELDS = [
+    ("prompt_visibility", lambda s: s.prompt_visibility != "public"),
+]
+
+
+@click.command()
+@click.argument("manifest_file", type=click.Path(exists=True, path_type=Path))
+@click.option("--dry-run/--no-dry-run", default=True, help="Preview without executing.")
+@click.option(
+    "--allow-provider",
+    multiple=True,
+    help="Only allow these providers (can be specified multiple times).",
+)
+@click.option(
+    "--show-prompts",
+    is_flag=True,
+    help="Show public-visibility prompts in the summary. Non-public prompts are always redacted.",
+)
+@click.option("--force", is_flag=True, help="Skip manifest hash verification.")
+def replay(
+    manifest_file: Path,
+    dry_run: bool,
+    allow_provider: tuple[str, ...],
+    show_prompts: bool,
+    force: bool,
+) -> 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"))
+        manifest = parse_manifest(data)
+    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():
+        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()
+
+    run = manifest.run
+    _print_summary(run, show_prompts=show_prompts)
+
+    if dry_run:
+        click.echo()
+        click.echo("Dry run — no steps executed. Use --no-dry-run to execute.")
+        return
+
+    # Build and execute pipeline from manifest steps
+    click.echo()
+    click.echo("Replaying pipeline...")
+
+    allowed: tuple[str, ...] | None = allow_provider if allow_provider else None
+
+    # Safety: when no allowlist is provided, confirm each unique provider.
+    # A hostile manifest could reference any installed provider and execute
+    # paid API calls on the user's credentials without consent.
+    if allowed is None:
+        unique_providers = sorted({step.provider for step in run.steps})
+        click.echo(
+            "No --allow-provider allowlist set. Confirm each provider before execution:",
+            err=True,
+        )
+        confirmed: list[str] = []
+        for name in unique_providers:
+            if click.confirm(f"  Execute with provider '{name}'?", default=False):
+                confirmed.append(name)
+            else:
+                raise click.Abort()
+        allowed = tuple(confirmed)
+
+    # Detect chain mode from step inputs in the manifest
+    chain = _detect_chain_mode(run)
+    if chain:
+        click.echo("  Detected chain mode from manifest step inputs.", err=True)
+
+    # Cache providers by name to avoid re-instantiating
+    providers: dict[str, object] = {}
+    pipe = Pipeline(
+        run.name,
+        tenant_id=run.tenant_id,
+        project_id=run.project_id,
+        chain=chain,
+    )
+
+    # Reserved kwargs that Pipeline.step() accepts explicitly
+    _reserved = {"model", "prompt", "modality", "step_type", "seed", "negative_prompt"}
+
+    for step_idx, step in enumerate(run.steps):
+        if step.provider not in providers:
+            providers[step.provider] = _load_provider(step.provider, allowed)
+
+        # Warn about fields that can't be faithfully replayed
+        for field_name, has_value in _UNREPLAYABLE_FIELDS:
+            if has_value(step):
+                click.echo(
+                    f"  WARNING: Step {step_idx + 1} has {field_name}={getattr(step, field_name)}"
+                    f" which may not replay identically.",
+                    err=True,
+                )
+
+        # Strip reserved keys from params to avoid TypeError on collision
+        extra_params = {k: v for k, v in step.params.items() if k not in _reserved}
+
+        # Restore seed and negative_prompt if present
+        if step.seed is not None:
+            extra_params["seed"] = step.seed
+        if step.negative_prompt is not None:
+            extra_params["negative_prompt"] = step.negative_prompt
+
+        # Restore fallback_models and input_from from step metadata
+        fallback_models = step.metadata.get("_fallback_models")
+        input_from = step.metadata.get("_input_from")
+
+        pipe.step(
+            providers[step.provider],
+            model=step.model,
+            prompt=step.prompt,
+            modality=step.modality,
+            step_type=step.step_type,
+            fallback_models=fallback_models,
+            input_from=input_from,
+            **extra_params,
+        )
+
+    try:
+        result = pipe.run()
+        click.echo()
+        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 Exception as exc:
+        raise click.ClickException(f"Replay failed: {exc}") from exc

genblaze_cli-0.2.0/genblaze_cli/commands/verify.py

@@ -0,0 +1,41 @@
+"""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.2.0/genblaze_cli/main.py

@@ -0,0 +1,20 @@
+"""CLI entry point."""
+
+import click
+
+from genblaze_cli.commands.extract import extract
+from genblaze_cli.commands.index import index
+from genblaze_cli.commands.replay import replay
+from genblaze_cli.commands.verify import verify
+
+
+@click.group()
+@click.version_option(package_name="genblaze-cli")
+def cli() -> None:
+    """genblaze — media generation manifest toolkit."""
+
+
+cli.add_command(extract)
+cli.add_command(index)
+cli.add_command(replay)
+cli.add_command(verify)

genblaze_cli-0.2.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "genblaze-cli"
+version = "0.2.0"
+description = "CLI for genblaze manifest operations"
+authors = [{name = "Jeronimo De Leon", email = "jdeleon@backblaze.com"}]
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Environment :: Console",
+]
+dependencies = [
+    "genblaze-core>=0.2.0,<0.3",
+    "click>=8.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/backblaze-labs/genblaze"
+Repository = "https://github.com/backblaze-labs/genblaze"
+Changelog = "https://github.com/backblaze-labs/genblaze/blob/main/CHANGELOG.md"
+Issues = "https://github.com/backblaze-labs/genblaze/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pillow>=10.0",
+]
+
+[project.scripts]
+genblaze = "genblaze_cli.main:cli"
+
+[tool.hatch.build.targets.wheel]
+packages = ["genblaze_cli"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

genblaze_cli-0.2.0/tests/test_cli.py

@@ -0,0 +1,145 @@
+"""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