pymcap-cli 0.13.0__tar.gz → 0.16.0__tar.gz

{pymcap_cli-0.13.0 → pymcap_cli-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymcap-cli
-Version: 0.13.0
+Version: 0.16.0
 Summary: High-performance Python CLI for MCAP file processing with advanced recovery, filtering, and optimization capabilities
 Keywords: mcap,cli,robotics,ros,ros2,recovery,filtering,compression
 Author: Marko Bausch
@@ -29,7 +29,7 @@ Requires-Dist: ros-parser
 Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: typing-extensions>=4.15.0
-Requires-Dist: pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash] ; extra == 'all'
+Requires-Dist: pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash,serve] ; extra == 'all'
 Requires-Dist: robo-ws-bridge ; extra == 'bridge'
 Requires-Dist: mcap-codec-support[draco] ; extra == 'draco'
 Requires-Dist: pillow>=10.0 ; extra == 'image'
@@ -37,8 +37,15 @@ Requires-Dist: pymcap-cli[image,draco,bridge,xxhash] ; extra == 'lite'
 Requires-Dist: pyarrow>=15.0.0 ; extra == 'parquet'
 Requires-Dist: numpy>=1.24.0 ; extra == 'parquet'
 Requires-Dist: mcap-codec-support[pointcloud] ; extra == 'parquet'
+Requires-Dist: kaleido>=1.0.0 ; extra == 'plot'
 Requires-Dist: plotly>=6.0.0 ; extra == 'plot'
 Requires-Dist: mcap-codec-support[pointcloud] ; extra == 'pointcloud'
+Requires-Dist: datasette>=0.65.2,<1 ; extra == 'serve'
+Requires-Dist: datasette-block-robots>=1.1,<2 ; extra == 'serve'
+Requires-Dist: datasette-copyable>=0.3.2,<1 ; extra == 'serve'
+Requires-Dist: datasette-dashboards>=0.8.0,<1 ; extra == 'serve'
+Requires-Dist: datasette-export-notebook>=1.0.1,<2 ; extra == 'serve'
+Requires-Dist: datasette-vega>=0.6.2,<1 ; extra == 'serve'
 Requires-Dist: mcap-codec-support[video] ; extra == 'video'
 Requires-Dist: xxhash>=3.0.0 ; extra == 'xxhash'
 Requires-Python: >=3.10
@@ -53,6 +60,7 @@ Provides-Extra: lite
 Provides-Extra: parquet
 Provides-Extra: plot
 Provides-Extra: pointcloud
+Provides-Extra: serve
 Provides-Extra: video
 Provides-Extra: xxhash
 Description-Content-Type: text/markdown
@@ -415,6 +423,13 @@ Change MCAP file compression.
 ```bash
 pymcap-cli compress input.mcap -o output.mcap --compression zstd
 pymcap-cli compress input.mcap -o output.mcap --compression lz4
+
+# Compress in place: write to a temp file, validate it, then replace the source
+pymcap-cli compress input.mcap --in-place --compression zstd
+
+# Trade a little ratio for throughput: --fast (zstd fast mode), or pick a level
+pymcap-cli compress input.mcap -o output.mcap --fast
+pymcap-cli compress input.mcap -o output.mcap --compression-level -5
 ```
 
 ### `du` — Disk Usage Analysis
@@ -524,8 +539,22 @@ pymcap-cli index tree /data/recordings --max-depth 3
 # Query by topic/schema/time and inspect catalog-wide topics
 pymcap-cli index query /data/recordings --topic /camera/front --format json
 pymcap-cli index topics /camera --sort-by messages
+
+# Apply pending schema migrations to an existing catalog
+pymcap-cli index migrate
+
+# Browse the catalog in a local Datasette web UI (dashboards, charts, cross-links)
+pymcap-cli index serve
 ```
 
+`index serve` launches [Datasette](https://datasette.io/) against the sidecar DB
+with bundled dashboards, canned queries, and a render plugin. It needs the
+`serve` extra (`pip install 'pymcap-cli[serve]'`; in this workspace, use
+`uv run --package pymcap-cli --extra serve pymcap-cli index serve`). Datasette
+runs from the same environment so the plugin resolves. Use `--db` to point at a
+non-default catalog, `--port` to change the port (default 8001), and
+`--no-browser` to skip auto-open.
+
 ### `records` — Raw Record Dump
 
 Print every MCAP record in file order using its `repr`. Useful for inspecting

{pymcap_cli-0.13.0 → pymcap_cli-0.16.0}/README.md

@@ -356,6 +356,13 @@ Change MCAP file compression.
 ```bash
 pymcap-cli compress input.mcap -o output.mcap --compression zstd
 pymcap-cli compress input.mcap -o output.mcap --compression lz4
+
+# Compress in place: write to a temp file, validate it, then replace the source
+pymcap-cli compress input.mcap --in-place --compression zstd
+
+# Trade a little ratio for throughput: --fast (zstd fast mode), or pick a level
+pymcap-cli compress input.mcap -o output.mcap --fast
+pymcap-cli compress input.mcap -o output.mcap --compression-level -5
 ```
 
 ### `du` — Disk Usage Analysis
@@ -465,8 +472,22 @@ pymcap-cli index tree /data/recordings --max-depth 3
 # Query by topic/schema/time and inspect catalog-wide topics
 pymcap-cli index query /data/recordings --topic /camera/front --format json
 pymcap-cli index topics /camera --sort-by messages
+
+# Apply pending schema migrations to an existing catalog
+pymcap-cli index migrate
+
+# Browse the catalog in a local Datasette web UI (dashboards, charts, cross-links)
+pymcap-cli index serve
 ```
 
+`index serve` launches [Datasette](https://datasette.io/) against the sidecar DB
+with bundled dashboards, canned queries, and a render plugin. It needs the
+`serve` extra (`pip install 'pymcap-cli[serve]'`; in this workspace, use
+`uv run --package pymcap-cli --extra serve pymcap-cli index serve`). Datasette
+runs from the same environment so the plugin resolves. Use `--db` to point at a
+non-default catalog, `--port` to change the port (default 8001), and
+`--no-browser` to skip auto-open.
+
 ### `records` — Raw Record Dump
 
 Print every MCAP record in file order using its `repr`. Useful for inspecting

{pymcap_cli-0.13.0 → pymcap_cli-0.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymcap-cli"
-version = "0.13.0"
+version = "0.16.0"
 description = "High-performance Python CLI for MCAP file processing with advanced recovery, filtering, and optimization capabilities"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -46,16 +46,29 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-all = ["pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash]"]
+all = ["pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash,serve]"]
 lite = ["pymcap-cli[image,draco,bridge,xxhash]"]
 bridge = ["robo-ws-bridge"]
 draco = ["mcap-codec-support[draco]"]
 image = ["pillow>=10.0"]
 parquet = ["pyarrow>=15.0.0", "numpy>=1.24.0", "mcap-codec-support[pointcloud]"]
-plot = ["plotly>=6.0.0"]
+plot = [
+    "kaleido>=1.0.0",
+    "plotly>=6.0.0",
+]
 pointcloud = ["mcap-codec-support[pointcloud]"]
 video = ["mcap-codec-support[video]"]
 xxhash = ["xxhash>=3.0.0"]
+# `index serve` web UI. datasette<1 pin: datasette-dashboards 500s on the 1.0
+# pre-release. Run from the same env so the bundled pymcap_render plugin imports.
+serve = [
+    "datasette>=0.65.2,<1",
+    "datasette-block-robots>=1.1,<2",
+    "datasette-copyable>=0.3.2,<1",
+    "datasette-dashboards>=0.8.0,<1",
+    "datasette-export-notebook>=1.0.1,<2",
+    "datasette-vega>=0.6.2,<1",
+]
 
 
 [project.urls]

pymcap_cli-0.16.0/src/pymcap_cli/cmd/_run_processor.py

@@ -0,0 +1,260 @@
+"""Shared processor pipeline for transform commands."""
+
+import contextlib
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO
+from urllib.parse import urlparse
+
+from small_mcap import InvalidMagicError, McapError
+
+from pymcap_cli.core.input_handler import open_input
+from pymcap_cli.core.mcap_processor import (
+    InputFile,
+    InputOptions,
+    McapProcessor,
+    OutputOptions,
+    OverwriteCollisionPolicy,
+    ProcessingOptions,
+    ProcessingStats,
+)
+from pymcap_cli.core.rosbag2_layout import expand_bag_paths
+from pymcap_cli.utils import confirm_output_overwrite, read_info
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class ProcessorResult:
+    """Result of a processor run."""
+
+    stats: ProcessingStats
+    processor: McapProcessor
+
+
+def resolve_overwrite_policy(*, force: bool, no_clobber: bool) -> OverwriteCollisionPolicy | None:
+    """Map CLI overwrite flags to the processor overwrite policy."""
+    if force and no_clobber:
+        return None
+    if force:
+        return OverwriteCollisionPolicy.OVERWRITE
+    if no_clobber:
+        return OverwriteCollisionPolicy.ERROR
+    return OverwriteCollisionPolicy.ASK
+
+
+def _open_output_stream(output: Path, overwrite_policy: OverwriteCollisionPolicy) -> BinaryIO:
+    """Open a single-output destination with the configured overwrite policy."""
+    if overwrite_policy == OverwriteCollisionPolicy.ASK:
+        confirm_output_overwrite(output, force=False)
+    elif overwrite_policy == OverwriteCollisionPolicy.ERROR and output.exists():
+        raise FileExistsError(f"Output file '{output}' already exists.")
+
+    return output.open("wb")
+
+
+def run_processor(
+    *,
+    files: list[str],
+    output: Path,
+    input_options: InputOptions,
+    output_options: OutputOptions,
+) -> ProcessorResult:
+    """Open files, build ProcessingOptions, run McapProcessor, return results.
+
+    Raises any exception from McapProcessor.process() to the caller.
+    """
+    files = expand_bag_paths(files)
+    with contextlib.ExitStack() as stack:
+        input_files: list[InputFile] = []
+
+        for f in files:
+            stream, size = stack.enter_context(open_input(f))
+            input_files.append(InputFile(stream=stream, size=size, options=input_options))
+
+        output_stream = stack.enter_context(
+            _open_output_stream(output, output_options.overwrite_policy)
+        )
+
+        processing_options = ProcessingOptions(
+            inputs=input_files,
+            input_options=InputOptions.from_args(),
+            output_options=output_options,
+        )
+
+        processor = McapProcessor(processing_options)
+        stats = processor.process(output_stream)
+
+    return ProcessorResult(stats=stats, processor=processor)
+
+
+def validate_mcap_output(path: Path) -> bool:
+    """Return True iff the MCAP at ``path`` has a readable header and summary."""
+    try:
+        with path.open("rb") as f:
+            read_info(f)
+    except (McapError, InvalidMagicError, OSError, AssertionError) as e:
+        logger.debug(f"Output validation failed for {path}: {e}")
+        return False
+    return True
+
+
+def mcap_message_count(path: Path) -> int | None:
+    """Return the message count from an MCAP summary, or None if it can't be read."""
+    try:
+        with path.open("rb") as f:
+            info = read_info(f)
+    except (McapError, InvalidMagicError, OSError, AssertionError) as e:
+        logger.debug(f"Could not read message count for {path}: {e}")
+        return None
+    if info.summary.statistics is None:
+        return None
+    return info.summary.statistics.message_count
+
+
+def _outputs_dropped_all_messages(sources: list[str], outputs: list[Path]) -> bool:
+    """True if every output has zero messages while some local source had messages.
+
+    Guards against deleting sources when a transform silently produced empty output
+    (e.g. the source was truncated before being read). Partial drops — dedup, time or
+    channel filters — are intentionally not flagged; only total loss is.
+    """
+    out_total = 0
+    for p in outputs:
+        count = mcap_message_count(p)
+        if count is None:
+            return False  # unknown — validation already passed, don't second-guess it
+        out_total += count
+    if out_total > 0:
+        return False
+    for src in sources:
+        if urlparse(src).scheme in ("http", "https"):
+            continue  # URLs are never deleted, so their counts don't matter
+        count = mcap_message_count(Path(src))
+        if count:
+            return True
+    return False
+
+
+def _outputs_lost_messages(sources: list[str], outputs: list[Path]) -> bool:
+    """True if the outputs hold fewer messages in total than the local sources.
+
+    For lossless transforms (compress) every source message must appear in the
+    output, so any shortfall means data was dropped. Counts that can't be read
+    are treated as unknown and never trigger a block.
+    """
+    out_total = 0
+    for p in outputs:
+        count = mcap_message_count(p)
+        if count is None:
+            return False
+        out_total += count
+    src_total = 0
+    for src in sources:
+        if urlparse(src).scheme in ("http", "https"):
+            continue
+        count = mcap_message_count(Path(src))
+        if count is None:
+            return False
+        src_total += count
+    return out_total < src_total
+
+
+def processing_had_errors(stats: ProcessingStats) -> bool:
+    """True if the processor swallowed read/validation errors during the run.
+
+    Such a run produces incomplete output even when it exits cleanly, so it is
+    not safe to delete or replace the source from it.
+    """
+    return stats.errors_encountered > 0 or stats.validation_errors > 0
+
+
+def delete_source_files(sources: list[str], outputs: list[Path]) -> None:
+    """Delete each local source file. Skip URLs and any source path that
+    resolves to one of ``outputs`` (with a warning).
+    """
+    output_resolved = {p.resolve() for p in outputs}
+    for src in sources:
+        scheme = urlparse(src).scheme
+        if scheme in ("http", "https"):
+            logger.warning(f"Skipping delete: '{src}' is a remote URL")
+            continue
+        path = Path(src)
+        try:
+            resolved = path.resolve()
+        except OSError as e:
+            logger.warning(f"Skipping delete '{src}': {e}")
+            continue
+        if resolved in output_resolved:
+            logger.warning(f"Skipping delete: source '{src}' is also an output")
+            continue
+        try:
+            path.unlink()
+            logger.info(f"Deleted source: {src}")
+        except FileNotFoundError:
+            logger.debug(f"Source already gone: {src}")
+        except OSError:
+            logger.exception(f"Failed to delete '{src}'")
+
+
+def in_place_temp_path(source: Path) -> Path:
+    """Temp output path next to ``source`` so the final rename stays on one filesystem."""
+    return source.with_name(source.name + ".tmp")
+
+
+def finalize_replace_source(*, source: Path, tmp_output: Path) -> int:
+    """Validate ``tmp_output`` and atomically replace ``source`` with it.
+
+    Returns 0 on success and 1 if the temp output failed validation or is empty
+    while the source had messages. In those cases the source is preserved and the
+    temp file is removed.
+    """
+    if not validate_mcap_output(tmp_output):
+        logger.error(f"[red]Output failed validation: {tmp_output}[/red]")
+        logger.error("Source file preserved — output not safe to replace source.")
+        tmp_output.unlink(missing_ok=True)
+        return 1
+    if _outputs_lost_messages([str(source)], [tmp_output]):
+        logger.error("Output has fewer messages than the source — source file preserved.")
+        tmp_output.unlink(missing_ok=True)
+        return 1
+    tmp_output.replace(source)
+    logger.info(f"Replaced source: {source}")
+    return 0
+
+
+def finalize_delete_source(
+    *,
+    sources: list[str],
+    outputs: list[Path],
+    require_lossless: bool = False,
+) -> int:
+    """Validate every output and, if all valid, delete the eligible sources.
+
+    Returns 0 on success (sources deleted or skipped with warning) and 1 if there
+    are no outputs, any output failed validation, or every output is empty while a
+    source had messages. No sources are deleted in those cases.
+
+    When ``require_lossless`` is set (transforms that must preserve every message,
+    e.g. ``compress``), any shortfall in total output messages versus the sources
+    also preserves them — not just total loss.
+    """
+    if not outputs:
+        logger.error("No output files were produced — source file(s) preserved.")
+        return 1
+    invalid = [p for p in outputs if not validate_mcap_output(p)]
+    if invalid:
+        for p in invalid:
+            logger.error(f"[red]Output failed validation: {p}[/red]")
+        logger.error("Source file(s) preserved — output not safe to replace source.")
+        return 1
+    if require_lossless:
+        if _outputs_lost_messages(sources, outputs):
+            logger.error("Output has fewer messages than the source(s) — source file(s) preserved.")
+            return 1
+    elif _outputs_dropped_all_messages(sources, outputs):
+        logger.error("Output contains no messages but the source did — source file(s) preserved.")
+        return 1
+    delete_source_files(sources, outputs)
+    return 0

{pymcap_cli-0.13.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/_run_processor_multi.py

@@ -11,6 +11,7 @@ from pymcap_cli.core.mcap_processor import (
     OutputOptions,
     ProcessingOptions,
 )
+from pymcap_cli.core.rosbag2_layout import expand_bag_paths
 
 
 def run_processor_multi(
@@ -28,6 +29,9 @@ def run_processor_multi(
     """
     if input_options is None:
         input_options = InputOptions.from_args()
+    files = expand_bag_paths(files)
+    # Let the OutputManager refuse to open a segment that would truncate an input.
+    output_options.input_paths = tuple(files)
     with contextlib.ExitStack() as stack:
         input_files: list[InputFile] = []
 

{pymcap_cli-0.13.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/bag2mcap_cmd.py

@@ -37,6 +37,7 @@ class Bag2McapOptions:
     compression: WriterCompression = DEFAULT_COMPRESSION
     enable_crcs: bool = True
     use_chunking: bool = True
+    zstd_level: int | None = None
 
 
 @dataclass

pymcap_cli-0.16.0/src/pymcap_cli/cmd/compress_cmd.py

@@ -0,0 +1,168 @@
+"""Compress command for pymcap-cli."""
+
+import logging
+from pathlib import Path
+from urllib.parse import urlparse
+
+from rich.console import Console
+
+from pymcap_cli.cmd._run_processor import (
+    finalize_delete_source,
+    finalize_replace_source,
+    in_place_temp_path,
+    processing_had_errors,
+    resolve_overwrite_policy,
+    run_processor,
+)
+from pymcap_cli.constants import DEFAULT_CHUNK_SIZE, DEFAULT_COMPRESSION
+from pymcap_cli.core.mcap_processor import (
+    InputOptions,
+    OutputOptions,
+    OverwriteCollisionPolicy,
+)
+from pymcap_cli.types.types_manual import (
+    ChunkSizeOption,
+    CompressionLevelOption,
+    CompressionOption,
+    DeleteSourceOption,
+    FastCompressionOption,
+    ForceOverwriteOption,
+    InPlaceOption,
+    NoClobberOption,
+    OutputPathOption,
+)
+from pymcap_cli.utils import output_overwrites_input
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+# zstd "fast" mode: a negative level trades ~5% larger output for roughly 2x
+# compression throughput. Used by --fast.
+_FAST_ZSTD_LEVEL = -1
+
+
+def compress(
+    file: str,
+    output: OutputPathOption | None = None,
+    *,
+    chunk_size: ChunkSizeOption = DEFAULT_CHUNK_SIZE,
+    compression: CompressionOption = DEFAULT_COMPRESSION,
+    force: ForceOverwriteOption = False,
+    no_clobber: NoClobberOption = False,
+    delete_source: DeleteSourceOption = False,
+    in_place: InPlaceOption = False,
+    compression_level: CompressionLevelOption = None,
+    fast: FastCompressionOption = False,
+) -> int:
+    """Create a compressed copy of an MCAP file.
+
+    Copy data in an MCAP file to a new file, compressing the output.
+
+    Parameters
+    ----------
+    file
+        Path to the MCAP file to compress (local file or HTTP/HTTPS URL).
+    output
+        Output filename. Required unless --in-place is given.
+    chunk_size
+        Chunk size of output file in bytes.
+    compression
+        Compression algorithm for output file.
+    force
+        Force overwrite of output file without confirmation.
+    no_clobber
+        Fail instead of prompting if the output file already exists.
+    delete_source
+        Delete source file(s) after the output is validated (header + summary).
+        URL inputs and any source whose path equals the output are skipped.
+    in_place
+        Compress to a temp file next to the source and, after the output is
+        validated (header + summary), atomically replace the source with it.
+        Local files only; mutually exclusive with --output and --delete-source.
+    compression_level
+        zstd level. Omit for the library default (3). Negative levels select the
+        fast modes — much higher throughput for slightly larger output. Ignored
+        for non-zstd compression. Mutually exclusive with --fast.
+    fast
+        Shortcut for a fast zstd level (roughly 2x throughput, ~5% larger
+        output). Equivalent to ``--compression-level -1``.
+
+    Examples
+    --------
+    ```
+    pymcap-cli compress in.mcap -o out.mcap
+    pymcap-cli compress in.mcap --in-place
+    pymcap-cli compress in.mcap -o out.mcap --fast
+    ```
+    """
+    if fast and compression_level is not None:
+        logger.error("--fast and --compression-level cannot be used together.")
+        return 1
+    zstd_level = _FAST_ZSTD_LEVEL if fast else compression_level
+    if in_place:
+        if output is not None:
+            logger.error("--in-place and --output cannot be used together.")
+            return 1
+        if delete_source:
+            logger.error("--in-place and --delete-source cannot be used together.")
+            return 1
+        if urlparse(file).scheme in ("http", "https"):
+            logger.error("--in-place requires a local file, not a URL.")
+            return 1
+        output = in_place_temp_path(Path(file))
+        overwrite_policy = OverwriteCollisionPolicy.OVERWRITE
+    else:
+        if output is None:
+            logger.error("Either --output or --in-place is required.")
+            return 1
+        if output_overwrites_input(file, output):
+            logger.error(
+                "Output path is the same file as the input. "
+                "Use --in-place to compress in place safely."
+            )
+            return 1
+        policy = resolve_overwrite_policy(force=force, no_clobber=no_clobber)
+        if policy is None:
+            logger.error("--force and --no-clobber cannot be used together.")
+            return 1
+        overwrite_policy = policy
+
+    logger.info(f"Compressing '{file}' to '{output}'")
+
+    try:
+        result = run_processor(
+            files=[file],
+            output=output,
+            # Do not force always_decode_chunk — the processor now has a
+            # chunk-level RECOMPRESS path that avoids per-message parsing.
+            input_options=InputOptions.from_args(),
+            output_options=OutputOptions(
+                compression=compression,
+                chunk_size=chunk_size,
+                overwrite_policy=overwrite_policy,
+                zstd_level=zstd_level,
+            ),
+        )
+        logger.info("[green]✓ Compression completed successfully![/green]")
+        console.print(result.stats)
+    except Exception:
+        logger.exception("Error during compression")
+        # The output was opened "wb" (truncated) before processing, so a failed run
+        # leaves an empty/partial file. Remove it rather than leaving a 0-byte result.
+        output.unlink(missing_ok=True)
+        return 1
+
+    if in_place:
+        if processing_had_errors(result.stats):
+            logger.error("Processing reported errors — source preserved, not replaced in place.")
+            output.unlink(missing_ok=True)
+            return 1
+        return finalize_replace_source(source=Path(file), tmp_output=output)
+
+    if delete_source:
+        if processing_had_errors(result.stats):
+            logger.error("Processing reported errors — source file preserved.")
+            return 1
+        return finalize_delete_source(sources=[file], outputs=[output], require_lossless=True)
+
+    return 0

{pymcap_cli-0.13.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/convert_cmd.py

@@ -43,6 +43,7 @@ class ConvertOptions:
     compression: WriterCompression = DEFAULT_COMPRESSION
     enable_crcs: bool = True
     use_chunking: bool = True
+    zstd_level: int | None = None
 
 
 @dataclass

{pymcap_cli-0.13.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/index/__init__.py

@@ -12,9 +12,11 @@ from cyclopts import App
 from pymcap_cli.cmd.index.duplicates_cmd import duplicates_cmd
 from pymcap_cli.cmd.index.errors_cmd import errors_cmd
 from pymcap_cli.cmd.index.info_cmd import info_cmd
+from pymcap_cli.cmd.index.migrate_cmd import migrate_cmd
 from pymcap_cli.cmd.index.query_cmd import query_cmd
 from pymcap_cli.cmd.index.scan_cmd import scan_cmd
 from pymcap_cli.cmd.index.schemas_cmd import schemas_cmd
+from pymcap_cli.cmd.index.serve_cmd import index_serve
 from pymcap_cli.cmd.index.sessions_cmd import sessions_cmd
 from pymcap_cli.cmd.index.status_cmd import status_cmd
 from pymcap_cli.cmd.index.timeline_cmd import timeline_cmd
@@ -39,3 +41,5 @@ index_app.command(sessions_cmd, name="sessions")
 index_app.command(errors_cmd, name="errors")
 index_app.command(timeline_cmd, name="timeline")
 index_app.command(info_cmd, name="info")
+index_app.command(migrate_cmd, name="migrate")
+index_app.command(index_serve, name="serve")