@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/cdh/tools/generate_shared.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""Generate shared types from OpenAPI and AsyncAPI contracts."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import tempfile
+import time
+import traceback
+from pathlib import Path
+from typing import Any
+
+import yaml  # type: ignore[import-untyped]
+
+try:
+    from cdh.generators._runtime import build_context
+    from cdh.generators.cli import discover_all_plugins_merged
+    from cdh.generators.registry import (
+        DEFAULT_GENERATORS_DIR,
+        PluginManifest,
+        discover_plugins,
+        render,
+        set_plugins,
+    )
+except ModuleNotFoundError:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+    from cdh.generators._runtime import build_context
+    from cdh.generators.cli import discover_all_plugins_merged
+    from cdh.generators.registry import (
+        DEFAULT_GENERATORS_DIR,
+        PluginManifest,
+        discover_plugins,
+        render,
+        set_plugins,
+    )
+
+
+class GenerateError(Exception):
+    pass
+
+
+ALIASES = {"ts": "typescript", "py": "python", "cs": "csharp", "graphql": "graphql-schema", "proto": "protobuf"}
+SELF_TEST_IDENTIFIERS = {
+    "typescript": "export interface",
+    "python": "@dataclass",
+    "java": "public record",
+    "go": "struct",
+    "rust": "pub fn",
+    "csharp": "public class",
+    "kotlin": "data class",
+    "swift": "protocol",
+    "graphql-schema": "type Query",
+    "protobuf": "message Item",
+}
+SELF_TEST_SCHEMA: dict[str, Any] = {
+    "openapi": "3.0.0",
+    "info": {"title": "SelfTest", "version": "1.0.0"},
+    "components": {
+        "schemas": {
+            "Item": {
+                "type": "object",
+                "description": "An item used to verify generator plugins.",
+                "required": ["id", "name", "status"],
+                "properties": {
+                    "id": {"type": "string", "format": "uuid"},
+                    "name": {"type": "string"},
+                    "price": {"type": "number", "format": "double", "nullable": True},
+                    "status": {"type": "string", "enum": ["active", "archived"]},
+                    "createdAt": {"type": "string", "format": "date-time"},
+                    "tags": {"type": "array", "items": {"type": "string"}},
+                },
+            }
+        }
+    },
+}
+
+
+def _default_generators_dir() -> Path:
+    bundled = Path(__file__).resolve().parent.parent / "generators"
+    if bundled.is_dir():
+        return bundled
+    return DEFAULT_GENERATORS_DIR
+
+
+def _discover_with_user_and_project(
+    generators_dir: Path | None,
+    project_root: Path,
+) -> dict[str, PluginManifest]:
+    """Scan the bundled dir plus user and project-local plugin dirs.
+
+    If ``generators_dir`` is provided, only that directory is scanned
+    (backwards-compatible behaviour). Otherwise the bundled generators
+    are merged with ``~/.cdh/generators`` and ``<project>/aidlc/generators``
+    so plugins installed via ``cdh aidlc generators install`` are picked
+    up automatically. Later sources override earlier ones by plugin name.
+    """
+    if generators_dir is not None:
+        return discover_plugins(generators_dir)
+    merged: dict[str, PluginManifest] = {}
+    for _source, plugin in discover_all_plugins_merged(project_root=project_root).values():
+        merged[plugin.name] = plugin
+    return merged
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    try:
+        document = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except (OSError, yaml.YAMLError) as exc:
+        raise GenerateError(f"Unable to read {path}: {exc}") from exc
+    if not isinstance(document, dict):
+        raise GenerateError(f"Root YAML value must be a mapping: {path}")
+    return document
+
+
+def _find_yaml_files(project_root: Path) -> list[Path]:
+    files: list[Path] = []
+    for relative in ("aidlc/contracts/api", "aidlc/contracts/events"):
+        directory = project_root / relative
+        if directory.is_dir():
+            files.extend(sorted(directory.glob("*.yaml")))
+            files.extend(sorted(directory.glob("*.yml")))
+    return files
+
+
+def _canonical_language(language: str, plugins: dict[str, PluginManifest]) -> str:
+    value = ALIASES.get(language.strip(), language.strip())
+    if value not in plugins:
+        raise GenerateError(f"Unknown language '{language}'. Valid: {', '.join(sorted(plugins))}")
+    return value
+
+
+def _legacy_outdirs(
+    ts_outdir: Path | None,
+    py_outdir: Path | None,
+    java_outdir: Path | None,
+    go_outdir: Path | None,
+    rust_outdir: Path | None,
+) -> dict[str, Path | None]:
+    return {
+        "typescript": ts_outdir,
+        "python": py_outdir,
+        "java": java_outdir,
+        "go": go_outdir,
+        "rust": rust_outdir,
+    }
+
+
+def _write_indexes(language: str, output_dir: Path, files: list[Path]) -> list[Path]:
+    if language == "typescript":
+        index = output_dir / "index.ts"
+        exports = ["// Auto-generated by generate_shared.py", ""]
+        exports.extend(f"export * from './{path.stem}';" for path in files)
+        index.write_text("\n".join(exports) + "\n", encoding="utf-8")
+        return [index]
+    if language == "python":
+        index = output_dir / "__init__.py"
+        imports = ['"""Auto-generated by generate_shared.py"""', ""]
+        imports.extend(f"from .{path.stem} import *" for path in files)
+        index.write_text("\n".join(imports) + "\n", encoding="utf-8")
+        return [index]
+    return []
+
+
+def generate(
+    project_root: Path,
+    ts_outdir: Path | None = None,
+    py_outdir: Path | None = None,
+    java_outdir: Path | None = None,
+    go_outdir: Path | None = None,
+    rust_outdir: Path | None = None,
+    languages: list[str] | None = None,
+    generators_dir: Path | None = None,
+    output_dirs: dict[str, Path] | None = None,
+    package_name: str | None = None,
+) -> list[Path]:
+    plugins = _discover_with_user_and_project(generators_dir, project_root)
+    set_plugins(plugins)
+    selected = [_canonical_language(language, plugins) for language in (languages or ["typescript", "python"])]
+    legacy = _legacy_outdirs(ts_outdir, py_outdir, java_outdir, go_outdir, rust_outdir)
+    overrides = output_dirs or {}
+    contracts = _find_yaml_files(project_root)
+    generated: list[Path] = []
+    shared = project_root / "aidlc" / "packages" / "shared"
+    for language in selected:
+        plugin = plugins[language]
+        output_dir = overrides.get(language) or legacy.get(language)
+        if output_dir is None:
+            output_dir = shared if plugin.default_outdir in ("", ".") else shared / plugin.default_outdir
+        output_dir.mkdir(parents=True, exist_ok=True)
+        stubs: list[Path] = []
+        for source in contracts:
+            document = _load_yaml(source)
+            context = build_context(document, source, language, package_name or plugin.package_name_default)
+            filename = plugin.output_filename_template.format(name=source.stem)
+            target = output_dir / filename
+            target.write_text(render(language, context), encoding="utf-8")
+            stubs.append(target)
+            generated.append(target)
+            print(f"  {plugin.display_name:<16} {target}")
+        generated.extend(_write_indexes(language, output_dir, stubs))
+    return generated
+
+
+def _self_test(generators_dir: Path | None = None) -> int:
+    failures: list[str] = []
+    with tempfile.TemporaryDirectory() as temporary:
+        root = Path(temporary)
+        contract_dir = root / "aidlc" / "contracts" / "api"
+        contract_dir.mkdir(parents=True)
+        (contract_dir / "selftest.yaml").write_text(yaml.safe_dump(SELF_TEST_SCHEMA), encoding="utf-8")
+        plugins = _discover_with_user_and_project(generators_dir, root)
+        set_plugins(plugins)
+        output_dirs = {name: root / "output" / name for name in plugins}
+        try:
+            generate(root, languages=list(plugins), generators_dir=generators_dir, output_dirs=output_dirs)
+        except Exception as exc:
+            traceback.print_exc()
+            failures.append(f"generation raised: {exc}")
+        for name, plugin in plugins.items():
+            output = output_dirs[name] / plugin.output_filename_template.format(name="selftest")
+            if not output.is_file():
+                failures.append(f"[{name}] missing {output.name}")
+                continue
+            identifier = SELF_TEST_IDENTIFIERS.get(name)
+            if identifier and identifier not in output.read_text(encoding="utf-8"):
+                failures.append(f"[{name}] missing expected identifier: {identifier}")
+    if failures:
+        print("Self-test FAILED:")
+        for failure in failures:
+            print(f"  - {failure}")
+        return 1
+    print(f"Self-test PASSED: all {len(plugins)} plugins produced expected output.")
+    return 0
+
+
+def _watch(project_root: Path, arguments: argparse.Namespace, languages: list[str]) -> None:
+    previous = {path: path.stat().st_mtime_ns for path in _find_yaml_files(project_root)}
+    while True:
+        try:
+            time.sleep(2)
+            current_files = _find_yaml_files(project_root)
+            current = {path: path.stat().st_mtime_ns for path in current_files}
+            if current != previous:
+                previous = current
+                generate(project_root, languages=languages, generators_dir=arguments.generators_dir)
+        except KeyboardInterrupt:
+            return
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--project-root", default=".")
+    parser.add_argument("--generators-dir", type=Path)
+    parser.add_argument("--languages", help="Comma-separated plugin names")
+    parser.add_argument("--package-name")
+    parser.add_argument("--ts-outdir", type=Path)
+    parser.add_argument("--py-outdir", type=Path)
+    parser.add_argument("--java-outdir", type=Path)
+    parser.add_argument("--go-outdir", type=Path)
+    parser.add_argument("--rust-outdir", type=Path)
+    parser.add_argument("--watch", action="store_true")
+    parser.add_argument("--self-test", action="store_true")
+    parser.add_argument("--list-generators", action="store_true")
+    return parser
+
+
+def main() -> None:
+    arguments = _parser().parse_args()
+    project_root = Path(arguments.project_root).resolve()
+    if arguments.generators_dir is not None:
+        plugins = discover_plugins(arguments.generators_dir)
+    else:
+        plugins = _discover_with_user_and_project(None, project_root)
+    if arguments.list_generators:
+        for name, plugin in plugins.items():
+            print(f"{name}\t{plugin.display_name}\t{plugin.file_extension}")
+        return
+    if arguments.self_test:
+        raise SystemExit(_self_test(arguments.generators_dir))
+    languages = [part.strip() for part in arguments.languages.split(",")] if arguments.languages else ["typescript", "python"]
+    root = Path(arguments.project_root).resolve()
+    kwargs = {
+        "ts_outdir": arguments.ts_outdir,
+        "py_outdir": arguments.py_outdir,
+        "java_outdir": arguments.java_outdir,
+        "go_outdir": arguments.go_outdir,
+        "rust_outdir": arguments.rust_outdir,
+        "languages": languages,
+        "generators_dir": arguments.generators_dir,
+        "package_name": arguments.package_name,
+    }
+    generated = generate(root, **kwargs)
+    print(f"Generated {len(generated)} file(s).")
+    if arguments.watch:
+        _watch(root, arguments, languages)
+
+
+if __name__ == "__main__":
+    main()

package/cdh/tools/iac_gen.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Generate Pulumi and Terraform resource declarations from provider YAML."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover
+    yaml = None
+
+PROVIDERS = {"tcb", "aliyun"}
+ENVIRONMENTS = {"preview", "staging", "production"}
+FORMATS = {"pulumi-py", "pulumi-ts", "terraform", "all"}
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    if yaml is None:
+        raise RuntimeError("PyYAML is required; install the 'pyyaml' package")
+    value = yaml.safe_load(path.read_text(encoding="utf-8"))
+    return value if isinstance(value, dict) else {}
+
+
+def _project_components(project: dict[str, Any]) -> list[str]:
+    stack = project.get("stack", {})
+    components = stack.get("components", []) if isinstance(stack, dict) else []
+    result: list[str] = []
+    for component in components:
+        if isinstance(component, str):
+            result.append(component)
+        elif isinstance(component, dict) and component.get("id"):
+            result.append(str(component["id"]))
+    return result
+
+
+def _resource_map(provider: str, name: str, config: dict[str, Any]) -> list[dict[str, Any]]:
+    kind = str(config.get("type", name)).lower()
+    if provider == "tcb":
+        types = {
+            "backend": "cloudbase_run.Service",
+            "cloudbase_run": "cloudbase_run.Service",
+            "web": "hosting.StaticSite",
+            "cloudbase_hosting": "hosting.StaticSite",
+            "database": "document_db.Database",
+            "documentdb": "document_db.Database",
+            "storage": "storage.Bucket",
+        }
+        return [{"name": name, "type": types.get(kind, kind), "config": config}]
+    types = {
+        "backend": "fc.Function",
+        "function": "fc.Function",
+        "web": "oss.Bucket",
+        "oss": "oss.Bucket",
+        "database": "rds.Instance",
+        "rds": "rds.Instance",
+        "storage": "oss.Bucket",
+    }
+    resources = [{"name": name, "type": types.get(kind, kind), "config": config}]
+    if name == "web" and config.get("cdn_enabled"):
+        resources.append({"name": "web_cdn", "type": "cdn.Distribution", "config": config})
+    return resources
+
+
+def _resources(provider: str, deployment: dict[str, Any], project: dict[str, Any]) -> list[dict[str, Any]]:
+    declared = deployment.get("resources", {})
+    if not isinstance(declared, dict):
+        declared = {}
+    names = list(declared)
+    for name in _project_components(project):
+        if name not in names and name in {"backend", "web", "database", "storage"}:
+            names.append(name)
+    result: list[dict[str, Any]] = []
+    for name in names:
+        config = declared.get(name, {})
+        result.extend(_resource_map(provider, str(name), config if isinstance(config, dict) else {}))
+    return result
+
+
+def _identifier(value: str) -> str:
+    value = re.sub(r"[^A-Za-z0-9_]", "_", value)
+    return value if value and not value[0].isdigit() else f"resource_{value}"
+
+
+def _py_value(value: Any, indent: int = 0) -> str:
+    return repr(value)
+
+
+def render_pulumi_py(provider: str, environment: str, resources: list[dict[str, Any]]) -> str:
+    module = "pulumi_tcb" if provider == "tcb" else "pulumi_alicloud"
+    lines = [f"import {module} as cloud", "", f"environment = {_py_value(environment)}", ""]
+    for resource in resources:
+        config = resource["config"]
+        args: list[str] = []
+        for key, value in config.items():
+            if key == "type":
+                continue
+            args.append(f"    {key}={_py_value(value)},")
+        lines.append(f'{_identifier(resource["name"])} = cloud.{resource["type"]}({resource["name"]!r},')
+        lines.extend(args)
+        lines.append(")")
+        lines.append("")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _hcl_key(key: str) -> str:
+    return {"runtime": "runtime_environment", "memory_mb": "memory", "timeout_sec": "timeout"}.get(key, key)
+
+
+def _hcl_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, list):
+        return json.dumps(value)
+    if isinstance(value, dict):
+        return json.dumps(value)
+    return json.dumps(str(value))
+
+
+def _terraform_type(provider: str, resource: dict[str, Any]) -> str:
+    name = resource["name"]
+    kind = resource["type"]
+    if provider == "tcb":
+        return {"cloudbase_run.Service": "tencentcloud_cloud_run_service", "hosting.StaticSite": "tencentcloud_cos_bucket", "document_db.Database": "tencentcloud_mongodb_instance", "storage.Bucket": "tencentcloud_cos_bucket"}.get(kind, "tencentcloud_resource")
+    if name == "web_cdn":
+        return "tencentcloud_cdn_domain"
+    return {"fc.Function": "alicloud_fc_function", "oss.Bucket": "alicloud_oss_bucket", "rds.Instance": "alicloud_db_instance"}.get(kind, "alicloud_resource")
+
+
+def render_terraform(provider: str, environment: str, resources: list[dict[str, Any]]) -> str:
+    lines = [f'variable "environment" {{', f'  default = {environment!r}', "}", ""]
+    for resource in resources:
+        lines.append(f'resource "{_terraform_type(provider, resource)}" "{_identifier(resource["name"])}" {{')
+        for key, value in resource["config"].items():
+            if key != "type":
+                lines.append(f"  {_hcl_key(key)} = {_hcl_value(value)}")
+        lines.append("}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def generate(project_root: Path, provider: str, environment: str, output_format: str, outdir: Path) -> list[Path]:
+    provider_dir = project_root / "aidlc" / "providers" / provider
+    deployment = _load_yaml(provider_dir / "deployment.yaml")
+    preview = _load_yaml(provider_dir / "preview.yaml")
+    project = _load_yaml(project_root / "aidlc" / "project.yaml")
+    deployment = {**preview, **deployment}
+    resources = _resources(provider, deployment, project)
+    target = project_root / outdir
+    target.mkdir(parents=True, exist_ok=True)
+    written: list[Path] = []
+    if output_format in {"pulumi-py", "all"}:
+        path = target / "pulumi" / f"{environment}.py"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(render_pulumi_py(provider, environment, resources), encoding="utf-8")
+        written.append(path)
+    if output_format in {"pulumi-ts", "all"}:
+        path = target / "pulumi" / f"{environment}.ts"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(render_pulumi_ts(provider, environment, resources), encoding="utf-8")
+        written.append(path)
+    if output_format in {"terraform", "all"}:
+        path = target / "terraform" / f"{environment}.tf"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(render_terraform(provider, environment, resources), encoding="utf-8")
+        written.append(path)
+    return written
+
+
+def _ts_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, str):
+        return json.dumps(value)
+    return json.dumps(value)
+
+
+def render_pulumi_ts(provider: str, environment: str, resources: list[dict[str, Any]]) -> str:
+    module = "@pulumi/tcb" if provider == "tcb" else "@pulumi/alicloud"
+    lines = [f'import * as cloud from "{module}";', "", f"const environment = {_ts_value(environment)};", ""]
+    for resource in resources:
+        lines.append(f"const {_identifier(resource['name'])} = new cloud.{resource['type']}({_ts_value(resource['name'])}, {{")
+        for key, value in resource["config"].items():
+            if key != "type":
+                lines.append(f"  {key}: {_ts_value(value)},")
+        lines.extend(["});", ""])
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def self_test() -> None:
+    deployment = {"resources": {"backend": {"type": "cloudbase_run", "runtime": "python3.11", "memory_mb": 512, "timeout_sec": 30, "env_vars": ["DATABASE_URL"]}, "web": {"type": "cloudbase_hosting", "cdn_enabled": True}}}
+    resources = _resources("tcb", deployment, {"stack": {"components": []}})
+    assert "runtime_environment" in render_terraform("tcb", "preview", resources)
+    assert "cloudbase_run.Service" in render_pulumi_py("tcb", "preview", resources)
+    print("self-test passed")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--project-root", type=Path, default=Path("."))
+    parser.add_argument("--provider", choices=sorted(PROVIDERS), required=False, default="tcb")
+    parser.add_argument("--environment", choices=sorted(ENVIRONMENTS), default="preview")
+    parser.add_argument("--format", dest="output_format", choices=sorted(FORMATS), default="all")
+    parser.add_argument("--outdir", type=Path, default=Path("aidlc/iac"))
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args()
+    if args.self_test:
+        self_test()
+        return
+    for path in generate(args.project_root, args.provider, args.environment, args.output_format, args.outdir):
+        print(path)
+
+
+if __name__ == "__main__":
+    main()

package/cdh/tools/otel_export.py

@@ -0,0 +1,125 @@
+"""Standalone OTLP exporter for the agenttrace SQLite database.
+
+Usage::
+
+    python -m cdh.tools.otel_export --endpoint http://localhost:4318 --since 2026-07-01
+    python -m cdh.tools.otel_export --service-name cdh-prod --session <sid>
+    python -m cdh.tools.otel_export --dry-run --since 2026-07-01
+
+This script is intentionally dependency-free at import time — it uses only the
+Python standard library plus the helpers in :mod:`cdh.trace.otel_exporter`.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+from pathlib import Path
+
+# Make `cdh.trace.otel_exporter` importable when running this file directly
+# (i.e. ``python cdh/tools/otel_export.py``).
+_THIS = Path(__file__).resolve()
+_REPO_ROOT = _THIS.parents[2]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+from cdh.trace.otel_exporter import DEFAULT_DB_PATH, OtlpExporter  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Export agenttrace spans from the local sqlite DB to an OTLP/HTTP collector.",
+    )
+    parser.add_argument(
+        "--endpoint",
+        default=os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4318"),
+        help="OTLP/HTTP base endpoint (default: $OTEL_EXPORTER_OTLP_ENDPOINT or http://localhost:4318)",
+    )
+    parser.add_argument(
+        "--db-path",
+        type=Path,
+        default=DEFAULT_DB_PATH,
+        help=f"Path to the agenttrace sqlite DB (default: {DEFAULT_DB_PATH})",
+    )
+    parser.add_argument(
+        "--service-name",
+        default=os.environ.get("OTEL_SERVICE_NAME", "cdh"),
+        help="Value of the service.name resource attribute",
+    )
+    parser.add_argument(
+        "--since",
+        default=None,
+        help="Only export rows with timestamp >= this value (ISO date or datetime)",
+    )
+    parser.add_argument(
+        "--session",
+        default=None,
+        help="Restrict export to a single session_id",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=256,
+        help="Spans per HTTP POST (default: 256)",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=10.0,
+        help="Per-request HTTP timeout in seconds (default: 10)",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Build payloads but don't POST. Prints the would-be batch count.",
+    )
+    parser.add_argument(
+        "--header",
+        action="append",
+        default=[],
+        metavar="K=V",
+        help="Extra HTTP header (repeatable). e.g. --header 'Authorization=Bearer xxx'",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable debug logging",
+    )
+
+    args = parser.parse_args()
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    )
+
+    headers: dict[str, str] = {}
+    for h in args.header:
+        if "=" in h:
+            k, v = h.split("=", 1)
+            headers[k.strip()] = v.strip()
+
+    exporter = OtlpExporter(
+        db_path=args.db_path,
+        endpoint=args.endpoint,
+        service_name=args.service_name,
+        headers=headers,
+        batch_size=args.batch_size,
+        timeout_s=args.timeout,
+        dry_run=args.dry_run,
+    )
+
+    counters = exporter.export_since(since=args.since, session_id=args.session)
+
+    mode = "(dry-run) " if args.dry_run else ""
+    print(
+        f"{mode}OTLP export summary: "
+        f"read={counters['read']} sent={counters['sent']} "
+        f"failed={counters['failed']} batches={counters['batches']}"
+    )
+    if not args.dry_run and counters["failed"] > 0:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())