wxcli 1.2.0__py3-none-any.whl

wxcli/commands/converged_recordings.py

@@ -0,0 +1,347 @@
+import json
+import typer
+from wxcli.auth import get_api
+from wxcli.errors import WebexError, handle_rest_error
+from wxcli.output import print_table, print_json
+
+
+app = typer.Typer(help="Manage Webex Calling converged-recordings.")
+
+
+@app.command("list")
+def cmd_list(
+    from_param: str = typer.Option(None, "--from", help="Starting date and time (inclusive) for recordings to return,"),
+    to: str = typer.Option(None, "--to", help="Ending date and time (exclusive) for List recordings to retu"),
+    status: str = typer.Option(None, "--status", help="Choices: available, deleted"),
+    service_type: str = typer.Option(None, "--service-type", help="Choices: calling, customerAssist"),
+    format_param: str = typer.Option(None, "--format", help="Choices: MP3"),
+    owner_type: str = typer.Option(None, "--owner-type", help="Choices: user, place, virtualLine, callQueue"),
+    storage_region: str = typer.Option(None, "--storage-region", help="Choices: US, SG, GB, JP, DE, AU, IN, CA"),
+    location_id: str = typer.Option(None, "--location-id", help="Fetch recordings for users in a particular Webex Calling loc"),
+    topic: str = typer.Option(None, "--topic", help="Recording's topic. If specified, the API filters recordings"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Recordings."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if status is not None:
+        params["status"] = status
+    if service_type is not None:
+        params["serviceType"] = service_type
+    if format_param is not None:
+        params["format"] = format_param
+    if owner_type is not None:
+        params["ownerType"] = owner_type
+    if storage_region is not None:
+        params["storageRegion"] = storage_region
+    if location_id is not None:
+        params["locationId"] = location_id
+    if topic is not None:
+        params["topic"] = topic
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    try:
+        if limit > 0:
+            result = api.session.rest_get(url, params=params)
+            result = result or {}
+            items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+        else:
+            items = list(api.session.follow_pagination(url=url, params=params, item_key="items"))
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[("ID", "id"), ("Name", "name")], limit=limit)
+
+
+
+@app.command("list-converged-recordings")
+def list_converged_recordings(
+    from_param: str = typer.Option(None, "--from", help="Starting date and time (inclusive) for recordings to return,"),
+    to: str = typer.Option(None, "--to", help="Ending date and time (exclusive) for List recordings to retu"),
+    status: str = typer.Option(None, "--status", help="Choices: available, deleted, purged"),
+    service_type: str = typer.Option(None, "--service-type", help="Choices: calling, customerAssist"),
+    format_param: str = typer.Option(None, "--format", help="Choices: MP3"),
+    owner_id: str = typer.Option(None, "--owner-id", help="Webex user Id to fetch recordings for a particular user."),
+    owner_email: str = typer.Option(None, "--owner-email", help="Webex email address to fetch recordings for a particular use"),
+    owner_type: str = typer.Option(None, "--owner-type", help="Choices: user, place, virtualLine, callQueue"),
+    storage_region: str = typer.Option(None, "--storage-region", help="Choices: US, SG, GB, JP, DE, AU, IN, CA"),
+    location_id: str = typer.Option(None, "--location-id", help="Fetch recordings for users in a particular Webex Calling loc"),
+    topic: str = typer.Option(None, "--topic", help="Recording's topic. If specified, the API filters recordings"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+    limit: int = typer.Option(0, "--limit", help="Max results (0=all for paginated endpoints, API default for non-paginated)"),
+    offset: int = typer.Option(0, "--offset", help="Start offset"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """List Recordings for Admin or Compliance officer."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/admin/convergedRecordings"
+    params = {}
+    if from_param is not None:
+        params["from"] = from_param
+    if to is not None:
+        params["to"] = to
+    if status is not None:
+        params["status"] = status
+    if service_type is not None:
+        params["serviceType"] = service_type
+    if format_param is not None:
+        params["format"] = format_param
+    if owner_id is not None:
+        params["ownerId"] = owner_id
+    if owner_email is not None:
+        params["ownerEmail"] = owner_email
+    if owner_type is not None:
+        params["ownerType"] = owner_type
+    if storage_region is not None:
+        params["storageRegion"] = storage_region
+    if location_id is not None:
+        params["locationId"] = location_id
+    if topic is not None:
+        params["topic"] = topic
+    if limit > 0:
+        params["max"] = limit
+    if offset > 0:
+        params["start"] = offset
+    try:
+        if limit > 0:
+            result = api.session.rest_get(url, params=params)
+            result = result or {}
+            items = result.get("items", result.get("data", result if isinstance(result, list) else [])) if isinstance(result, dict) else (result if isinstance(result, list) else [])
+        else:
+            items = list(api.session.follow_pagination(url=url, params=params, item_key="items"))
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(items)
+    else:
+        print_table(items, columns=[("ID", "id"), ("Name", "name")], limit=limit)
+
+
+
+@app.command("show")
+def show(
+    recording_id: str = typer.Argument(help="recordingId"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Recording Details."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings/{recording_id}"
+    try:
+        result = api.session.rest_get(url)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("delete")
+def delete(
+    recording_id: str = typer.Argument(help="recordingId"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Delete a Recording."""
+    if not force:
+        typer.confirm(f"Delete {recording_id}?", abort=True)
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings/{recording_id}"
+    try:
+        api.session.rest_delete(url)
+    except WebexError as e:
+        handle_rest_error(e)
+    typer.echo(f"Deleted: {recording_id}")
+
+
+
+@app.command("show-metadata")
+def show_metadata(
+    recording_id: str = typer.Argument(help="recordingId"),
+    show_all_types: str = typer.Option(None, "--show-all-types", help="If `showAllTypes` is `true`, all attributes will be shown. I"),
+    output: str = typer.Option("json", "--output", "-o", help="Output format: table|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Get Recording metadata."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings/{recording_id}/metadata"
+    params = {}
+    if show_all_types is not None:
+        params["showAllTypes"] = show_all_types
+    try:
+        result = api.session.rest_get(url, params=params)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    else:
+        if isinstance(result, dict):
+            print_table([result], columns=[("Key", ""), ("Value", "")], limit=0)
+        elif isinstance(result, list):
+            print_table(result, columns=[("ID", "id"), ("Name", "name")], limit=0)
+        else:
+            print_json(result)
+
+
+
+@app.command("create")
+def create(
+    owner_email: str = typer.Option(None, "--owner-email", help="Recording owner email."),
+    owner_id: str = typer.Option(None, "--owner-id", help="Recording owner ID. Can be a user, a virtual line, or a work"),
+    reassign_owner_email: str = typer.Option(None, "--reassign-owner-email", help="(required) New owner of the recordings."),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Reassign Recordings\n\nExample --json-body:\n  '{"reassignOwnerEmail":"...","ownerEmail":"...","ownerID":"...","recordingIds":["..."]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings/reassign"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if owner_email is not None:
+            body["ownerEmail"] = owner_email
+        if owner_id is not None:
+            body["ownerID"] = owner_id
+        if reassign_owner_email is not None:
+            body["reassignOwnerEmail"] = reassign_owner_email
+        _missing = [f for f in ['reassignOwnerEmail'] if f not in body or body[f] is None]
+        if _missing:
+            typer.echo("Error: Missing required fields: " + ", ".join(_missing), err=True)
+            raise typer.Exit(1)
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+
+
+@app.command("create-soft-delete")
+def create_soft_delete(
+    trash_all: bool = typer.Option(None, "--trash-all/--no-trash-all", help="If not specified or `false`, moves the recordings specified"),
+    owner_email: str = typer.Option(None, "--owner-email", help="Email address for the recording owner. This parameter is onl"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Move Recordings into the Recycle Bin\n\nExample --json-body:\n  '{"trashAll":true,"ownerEmail":"...","recordingIds":["..."]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings/softDelete"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if trash_all is not None:
+            body["trashAll"] = trash_all
+        if owner_email is not None:
+            body["ownerEmail"] = owner_email
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+
+
+@app.command("create-restore")
+def create_restore(
+    restore_all: bool = typer.Option(None, "--restore-all/--no-restore-all", help="If not specified or `false`, restores the recordings specifi"),
+    owner_email: str = typer.Option(None, "--owner-email", help="Email address for the recording owner. This parameter is onl"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Restore Recordings from Recycle Bin\n\nExample --json-body:\n  '{"restoreAll":true,"ownerEmail":"...","recordingIds":["..."]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings/restore"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if restore_all is not None:
+            body["restoreAll"] = restore_all
+        if owner_email is not None:
+            body["ownerEmail"] = owner_email
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+
+
+@app.command("create-purge")
+def create_purge(
+    purge_all: bool = typer.Option(None, "--purge-all/--no-purge-all", help="If not specified or `false`, purges the recordings specified"),
+    owner_email: str = typer.Option(None, "--owner-email", help="Email address for the recording owner. This parameter is onl"),
+    json_body: str = typer.Option(None, "--json-body", help="Full JSON body (overrides other options)"),
+    output: str = typer.Option("id", "--output", "-o", help="Output format: id|json"),
+    debug: bool = typer.Option(False, "--debug"),
+):
+    """Purge Recordings from Recycle Bin\n\nExample --json-body:\n  '{"purgeAll":true,"ownerEmail":"...","recordingIds":["..."]}'."""
+    api = get_api(debug=debug)
+    url = f"https://webexapis.com/v1/convergedRecordings/purge"
+    if json_body:
+        body = json.loads(json_body)
+    else:
+        body = {}
+        if purge_all is not None:
+            body["purgeAll"] = purge_all
+        if owner_email is not None:
+            body["ownerEmail"] = owner_email
+    try:
+        result = api.session.rest_post(url, json=body)
+    except WebexError as e:
+        handle_rest_error(e)
+    if output == "json":
+        print_json(result)
+    elif isinstance(result, dict) and "id" in result:
+        typer.echo(f"Created: {result['id']}")
+    elif not result or result == {}:
+        typer.echo("Created.")
+    else:
+        print_json(result)
+
+

wxcli/commands/converged_recordings_export.py

@@ -0,0 +1,310 @@
+"""Download and bulk-export converged recording artifacts (audio, transcript, AI notes)."""
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import requests
+import typer
+from rich.console import Console
+from wxcli.errors import WebexError
+
+from wxcli.auth import get_api
+from wxcli.errors import handle_rest_error
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+BASE = "https://webexapis.com/v1"
+
+# Mapping from temporaryDirectDownloadLinks field → output filename
+ARTIFACT_MAP = {
+    "transcriptDownloadLink": ("transcript.txt", "transcript", False),
+    "suggestedNotesDownloadLink": ("suggested_notes.html", "suggestedNotes", False),
+    "shortNotesDownloadLink": ("short_notes.html", "shortNotes", False),
+    "actionItemsDownloadLink": ("action_items.html", "actionItems", False),
+    "audioDownloadLink": ("audio.mp3", "audioFile", True),
+}
+
+
+@dataclass
+class DownloadResult:
+    recording_id: str
+    metadata: dict
+    downloaded: list[str] = field(default_factory=list)
+    unavailable: list[str] = field(default_factory=list)
+    failed: list[str] = field(default_factory=list)
+    audio_path: str | None = None
+
+
+def download_recording_artifacts(
+    api,
+    recording_id: str,
+    output_dir: Path,
+    include_audio: bool = False,
+) -> DownloadResult:
+    """Fetch recording detail and download all available artifacts."""
+    url = f"{BASE}/convergedRecordings/{recording_id}"
+    detail = api.session.rest_get(url)
+
+    result = DownloadResult(recording_id=recording_id, metadata=detail)
+
+    # Write metadata.json
+    output_dir.mkdir(parents=True, exist_ok=True)
+    metadata_path = output_dir / "metadata.json"
+    metadata_path.write_text(json.dumps(detail, indent=2, default=str))
+
+    links = detail.get("temporaryDirectDownloadLinks") or {}
+
+    for link_field, (filename, _content_key, is_audio) in ARTIFACT_MAP.items():
+        if is_audio and not include_audio:
+            continue
+
+        download_url = links.get(link_field)
+        if not download_url:
+            result.unavailable.append(filename)
+            continue
+
+        try:
+            if is_audio:
+                resp = requests.get(download_url, timeout=300, stream=True)
+                resp.raise_for_status()
+            else:
+                resp = requests.get(download_url, timeout=300)
+                resp.raise_for_status()
+        except Exception as e:
+            logger.warning("Failed to download %s for %s: %s", filename, recording_id, e)
+            result.failed.append(filename)
+            continue
+
+        file_path = output_dir / filename
+        if is_audio:
+            with open(file_path, "wb") as f:
+                for chunk in resp.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            result.audio_path = str(file_path)
+        else:
+            file_path.write_text(resp.text, encoding="utf-8")
+
+        result.downloaded.append(filename)
+
+    return result
+
+
+def register(app: typer.Typer) -> None:
+    """Register download and export commands on the converged-recordings app."""
+
+    @app.command("download")
+    def download(
+        recording_id: str = typer.Argument(help="Recording ID to download"),
+        include_audio: bool = typer.Option(False, "--include-audio", help="Download the MP3 audio file"),
+        output_dir: str = typer.Option("./recordings", "--output-dir", "-d", help="Target directory"),
+        debug: bool = typer.Option(False, "--debug"),
+    ):
+        """Download a single recording's artifacts to a local directory."""
+        api = get_api(debug=debug)
+        out_path = Path(output_dir) / recording_id
+
+        console.print(f"Downloading recording {recording_id}...")
+
+        try:
+            result = download_recording_artifacts(api, recording_id, out_path, include_audio)
+        except WebexError as e:
+            handle_rest_error(e)
+            return  # unreachable — handle_rest_error always raises
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            raise typer.Exit(1)
+
+        # Summary
+        parts = []
+        if result.downloaded:
+            parts.append(f"downloaded: {', '.join(result.downloaded)}")
+        if result.unavailable:
+            parts.append(f"not available: {', '.join(result.unavailable)}")
+        if result.failed:
+            parts.append(f"failed: {', '.join(result.failed)}")
+
+        console.print(f"  Output: {out_path}")
+        console.print(f"  {'; '.join(parts)}")
+
+        if not result.downloaded:
+            raise typer.Exit(1)
+
+    @app.command("export")
+    def export(
+        from_date: str = typer.Option(..., "--from", help="Start date, ISO 8601 (required)"),
+        to_date: str = typer.Option(..., "--to", help="End date, ISO 8601 (required)"),
+        owner_email: str = typer.Option(None, "--owner-email", help="Filter by owner email"),
+        owner_id: str = typer.Option(None, "--owner-id", help="Filter by owner ID"),
+        owner_type: str = typer.Option(None, "--owner-type", help="Filter: user|place|virtualLine|callQueue"),
+        location_id: str = typer.Option(None, "--location-id", help="Filter by location ID"),
+        service_type: str = typer.Option(None, "--service-type", help="Filter: calling|customerAssist"),
+        status: str = typer.Option(None, "--status", help="Filter: available|deleted"),
+        topic: str = typer.Option(None, "--topic", help="Filter by topic keyword"),
+        include_audio: bool = typer.Option(False, "--include-audio", help="Download MP3 audio files"),
+        fmt: str = typer.Option("jsonl", "--format", help="Output format: jsonl|json-per-file"),
+        output_dir: str = typer.Option("./recording-export", "--output-dir", "-d", help="Target directory"),
+        limit: int = typer.Option(0, "--limit", help="Max recordings to export (0=all)"),
+        debug: bool = typer.Option(False, "--debug"),
+    ):
+        """Bulk export recordings with text/AI artifacts for BI consumption."""
+        api = get_api(debug=debug)
+        out_path = Path(output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+
+        # Build list query params
+        params: dict = {"from": from_date, "to": to_date}
+        if owner_email:
+            params["ownerEmail"] = owner_email
+        if owner_id:
+            params["ownerId"] = owner_id
+        if owner_type:
+            params["ownerType"] = owner_type
+        if location_id:
+            params["locationId"] = location_id
+        if service_type:
+            params["serviceType"] = service_type
+        if status:
+            params["status"] = status
+        if topic:
+            params["topic"] = topic
+
+        # Paginate the admin listing endpoint
+        console.print("Listing recordings...")
+        list_url = f"{BASE}/admin/convergedRecordings"
+        try:
+            recordings = list(api.session.follow_pagination(url=list_url, params=params, item_key="items"))
+            if limit > 0:
+                recordings = recordings[:limit]
+        except WebexError as e:
+            handle_rest_error(e)
+            return
+
+        if not recordings:
+            console.print("[yellow]No recordings found for the given filters.[/yellow]")
+            return
+
+        total = len(recordings)
+        console.print(f"Found {total} recording(s). Exporting...")
+
+        # Track stats
+        exported = 0
+        failed_ids: list[str] = []
+        artifact_counts: dict[str, int] = {"downloaded": 0, "unavailable": 0, "failed": 0}
+        audio_count = 0
+
+        # JSONL mode: open the output file
+        jsonl_file = None
+        if fmt == "jsonl":
+            jsonl_file = open(out_path / "recordings.jsonl", "w", encoding="utf-8")
+            if include_audio:
+                (out_path / "audio").mkdir(exist_ok=True)
+
+        try:
+            for i, rec in enumerate(recordings, 1):
+                rec_id = rec.get("id", "unknown")
+                console.print(f"Exporting recording {i}/{total} ({rec_id[:16]}...)...")
+
+                try:
+                    if fmt == "json-per-file":
+                        rec_dir = out_path / rec_id
+                        dl_result = download_recording_artifacts(api, rec_id, rec_dir, include_audio)
+                    else:
+                        # JSONL mode: fetch detail, download artifacts inline
+                        detail_url = f"{BASE}/convergedRecordings/{rec_id}"
+                        detail = api.session.rest_get(detail_url)
+                        links = detail.get("temporaryDirectDownloadLinks") or {}
+
+                        # Build the JSONL record — all metadata fields except download links
+                        record: dict = {
+                            k: v for k, v in detail.items()
+                            if k != "temporaryDirectDownloadLinks"
+                        }
+
+                        dl_result = DownloadResult(recording_id=rec_id, metadata=detail)
+
+                        # Download text artifacts inline
+                        for link_field, (filename, content_key, is_audio) in ARTIFACT_MAP.items():
+                            if is_audio:
+                                continue
+                            download_url = links.get(link_field)
+                            if not download_url:
+                                record[content_key] = None
+                                dl_result.unavailable.append(filename)
+                                continue
+                            try:
+                                resp = requests.get(download_url, timeout=300)
+                                resp.raise_for_status()
+                                record[content_key] = resp.text
+                                dl_result.downloaded.append(filename)
+                            except Exception as e:
+                                logger.warning("Failed to download %s for %s: %s", filename, rec_id, e)
+                                record[content_key] = None
+                                dl_result.failed.append(filename)
+
+                        # Audio (opt-in)
+                        if include_audio:
+                            audio_url = links.get("audioDownloadLink")
+                            if not audio_url:
+                                record["audioFile"] = None
+                                dl_result.unavailable.append("audio.mp3")
+                            else:
+                                try:
+                                    resp = requests.get(audio_url, timeout=300, stream=True)
+                                    resp.raise_for_status()
+                                    audio_path = out_path / "audio" / f"{rec_id}.mp3"
+                                    with open(audio_path, "wb") as af:
+                                        for chunk in resp.iter_content(chunk_size=8192):
+                                            af.write(chunk)
+                                    record["audioFile"] = f"audio/{rec_id}.mp3"
+                                    dl_result.audio_path = str(audio_path)
+                                    dl_result.downloaded.append("audio.mp3")
+                                except Exception as e:
+                                    logger.warning("Failed to download audio for %s: %s", rec_id, e)
+                                    record["audioFile"] = None
+                                    dl_result.failed.append("audio.mp3")
+                        else:
+                            record["audioFile"] = None
+
+                        jsonl_file.write(json.dumps(record, default=str) + "\n")
+                        jsonl_file.flush()
+
+                    exported += 1
+                    artifact_counts["downloaded"] += len(dl_result.downloaded)
+                    artifact_counts["unavailable"] += len(dl_result.unavailable)
+                    artifact_counts["failed"] += len(dl_result.failed)
+                    if dl_result.audio_path:
+                        audio_count += 1
+
+                except WebexError as e:
+                    logger.warning("Failed to export recording %s: %s", rec_id, e)
+                    failed_ids.append(rec_id)
+                except Exception as e:
+                    logger.warning("Failed to export recording %s: %s", rec_id, e)
+                    failed_ids.append(rec_id)
+
+        finally:
+            if jsonl_file:
+                jsonl_file.close()
+
+        # Final summary
+        console.print("")
+        console.print("[bold]Export Summary[/bold]")
+        console.print(f"  Total recordings: {total}")
+        console.print(f"  Exported:         {exported}")
+        console.print(f"  Failed:           {len(failed_ids)}")
+        console.print(f"  Artifacts downloaded:  {artifact_counts['downloaded']}")
+        console.print(f"  Artifacts unavailable: {artifact_counts['unavailable']}")
+        console.print(f"  Artifacts failed:      {artifact_counts['failed']}")
+        if include_audio:
+            console.print(f"  Audio files:      {audio_count}")
+        console.print(f"  Output directory: {out_path}")
+
+        if failed_ids:
+            console.print(f"\n[yellow]Failed recording IDs:[/yellow]")
+            for fid in failed_ids:
+                console.print(f"  - {fid}")
+            raise typer.Exit(1)