pyrobostudio-sidecar 0.1.0__tar.gz

pyrobostudio_sidecar-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: pyrobostudio-sidecar
+Version: 0.1.0
+Summary: PyRoboStudio data sidecar: recorded-session serving, capabilities, mission/time APIs
+Author: Georgi Mullassery
+Author-email: Georgi Mullassery <mullassery@gmail.com>
+License-Expression: MIT
+Requires-Dist: fastapi>=0.162.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: mcap>=1.6.0
+Requires-Dist: mcap-ros2-support>=0.6.0
+Requires-Dist: foxglove-sdk>=0.30
+Requires-Dist: websockets>=17.0
+Requires-Dist: uvicorn[standard]>=0.54.0
+Requires-Dist: h3>=4.5.0
+Requires-Dist: rosbags>=0.11.9
+Requires-Dist: pyarrow>=26.0.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# pyrobostudio-sidecar
+
+Python data sidecar for [PyRoboStudio](https://github.com/Mullassery/PyRoboStudio):
+a read-only FastAPI service that serves recorded robotics sessions, adapter views
+of PyRobo* repositories, mission manifests, and a Foxglove WebSocket transport.
+
+```sh
+uvx pyrobostudio-sidecar        # serves 127.0.0.1:8787
+```
+
+Read-only by design: the sidecar never publishes to robots or writes to source
+repositories. See the main repository for architecture, security model, and docs.

pyrobostudio_sidecar-0.1.0/README.md

@@ -0,0 +1,12 @@
+# pyrobostudio-sidecar
+
+Python data sidecar for [PyRoboStudio](https://github.com/Mullassery/PyRoboStudio):
+a read-only FastAPI service that serves recorded robotics sessions, adapter views
+of PyRobo* repositories, mission manifests, and a Foxglove WebSocket transport.
+
+```sh
+uvx pyrobostudio-sidecar        # serves 127.0.0.1:8787
+```
+
+Read-only by design: the sidecar never publishes to robots or writes to source
+repositories. See the main repository for architecture, security model, and docs.

pyrobostudio_sidecar-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "pyrobostudio-sidecar"
+version = "0.1.0"
+description = "PyRoboStudio data sidecar: recorded-session serving, capabilities, mission/time APIs"
+requires-python = ">=3.12"
+license = "MIT"
+readme = "README.md"
+dependencies = [
+    "fastapi>=0.162.0",
+    "httpx>=0.28.1",
+    "mcap>=1.6.0",
+    "mcap-ros2-support>=0.6.0",
+    "foxglove-sdk>=0.30",
+    "websockets>=17.0",
+    "uvicorn[standard]>=0.54.0",
+    "h3>=4.5.0",
+    "rosbags>=0.11.9",
+    "pyarrow>=26.0.1",
+]
+
+[[project.authors]]
+name = "Georgi Mullassery"
+email = "mullassery@gmail.com"
+
+[project.scripts]
+pyrobostudio-sidecar = "pyrobostudio_sidecar:main"
+
+[dependency-groups]
+dev = ["pytest>=9.2.0"]
+
+[build-system]
+requires = ["uv_build>=0.13.0,<0.14.0"]
+build-backend = "uv_build"

pyrobostudio_sidecar-0.1.0/pyproject.toml.orig

@@ -0,0 +1,32 @@
+[project]
+name = "pyrobostudio-sidecar"
+version = "0.1.0"
+description = "PyRoboStudio data sidecar: recorded-session serving, capabilities, mission/time APIs"
+authors = [
+    { name = "Georgi Mullassery", email = "mullassery@gmail.com" }
+]
+requires-python = ">=3.12"
+license = "MIT"
+readme = "README.md"
+dependencies = [
+    "fastapi>=0.162.0",
+    "httpx>=0.28.1",
+    "mcap>=1.6.0",
+    "mcap-ros2-support>=0.6.0",
+    "foxglove-sdk>=0.30",
+    "websockets>=17.0",
+    "uvicorn[standard]>=0.54.0",
+    "h3>=4.5.0",
+    "rosbags>=0.11.9",
+    "pyarrow>=26.0.1",
+]
+
+[project.scripts]
+pyrobostudio-sidecar = "pyrobostudio_sidecar:main"
+
+[dependency-groups]
+dev = ["pytest>=9.2.0"]
+
+[build-system]
+requires = ["uv_build>=0.13.0,<0.14.0"]
+build-backend = "uv_build"

pyrobostudio_sidecar-0.1.0/src/pyrobostudio_sidecar/__init__.py

@@ -0,0 +1,5 @@
+def main() -> None:
+    """Console entry point: run the sidecar server on 127.0.0.1:8787."""
+    import uvicorn
+
+    uvicorn.run("pyrobostudio_sidecar.server:app", host="127.0.0.1", port=8787)

pyrobostudio_sidecar-0.1.0/src/pyrobostudio_sidecar/fixtures_env.py

@@ -0,0 +1,50 @@
+"""Environment-test fixtures for networkintel + syncfleet adapters (verbatim upstream DDL subsets)."""
+import sqlite3
+from pathlib import Path
+
+NI_DDL = [
+    "CREATE TABLE scan_sessions (id INTEGER PRIMARY KEY, scan_time DATETIME NOT NULL, duration_seconds REAL, target VARCHAR(255), device_count INTEGER DEFAULT 0, finding_count INTEGER DEFAULT 0, status VARCHAR(50) DEFAULT 'completed', error_message TEXT)",
+    "CREATE TABLE devices (id INTEGER PRIMARY KEY, scan_id INTEGER REFERENCES scan_sessions(id), ip VARCHAR(45) NOT NULL, hostname VARCHAR(255), os VARCHAR(255), device_type VARCHAR(50) DEFAULT 'linux', is_online BOOLEAN DEFAULT 1, last_seen DATETIME NOT NULL, first_seen DATETIME NOT NULL)",
+    "CREATE TABLE services (id INTEGER PRIMARY KEY, device_id INTEGER REFERENCES devices(id), port INTEGER NOT NULL, name VARCHAR(100), version VARCHAR(255), protocol VARCHAR(10) DEFAULT 'tcp', state VARCHAR(50) DEFAULT 'open', first_seen DATETIME, last_seen DATETIME)",
+    "CREATE TABLE findings (id INTEGER PRIMARY KEY, scan_id INTEGER REFERENCES scan_sessions(id), device_ip VARCHAR(45), finding_type VARCHAR(50), severity VARCHAR(20), title VARCHAR(500), description TEXT, evidence TEXT, recommendation TEXT, business_impact TEXT, cve_id VARCHAR(50), cvss_score REAL, exploit_available BOOLEAN DEFAULT 0, found_at DATETIME, resolved_at DATETIME)",
+]
+
+SF_DDL = [
+    "CREATE TABLE operation_journal (id INTEGER PRIMARY KEY, dataset_id INTEGER REFERENCES datasets(id), entity_id VARCHAR(255), origin_node_id VARCHAR(255), origin_seq INTEGER NOT NULL, op_type INTEGER, schema_version INTEGER, payload BLOB, causal_metadata BLOB, created_at DATETIME, checksum BLOB)",
+    "CREATE TABLE replication_checkpoints (id INTEGER PRIMARY KEY, peer_id VARCHAR(255), dataset_id INTEGER, last_acked_seq INTEGER, last_applied_seq INTEGER, updated_at DATETIME)",
+    "CREATE TABLE conflicts (id INTEGER PRIMARY KEY, operation_id VARCHAR(255), local_operation_id VARCHAR(255), remote_operation_id VARCHAR(255), conflict_type INTEGER, detected_at DATETIME, resolved_at DATETIME, resolution TEXT)",
+    "CREATE TABLE datasets (id INTEGER PRIMARY KEY, dataset_id VARCHAR(255), schema_version INTEGER, conflict_policy VARCHAR(50), created_at DATETIME)",
+]
+
+
+def make_ni_db(path: Path) -> dict:
+    con = sqlite3.connect(path)
+    for ddl in NI_DDL:
+        con.execute(ddl)
+    con.execute("INSERT INTO scan_sessions VALUES (1, '2026-11-01 10:00:00', 4.2, '192.168.1.0/24', 2, 1, 'completed', NULL)")
+    con.execute("INSERT INTO devices VALUES (1, 1, '192.168.1.2', 'robot-1', 'Ubuntu', 'linux', 1, '2026-11-01', '2026-11-01')")
+    con.execute("INSERT INTO devices VALUES (2, 1, '192.168.1.3', 'robot-2', 'Ubuntu', 'linux', 0, '2026-11-01', '2026-11-01')")
+    con.execute("INSERT INTO services VALUES (1, 1, 2224, 'ros2-dds', NULL, 'udp', 'open', '2026-11-01', '2026-11-01')")
+    con.execute("INSERT INTO services VALUES (2, 1, 22, 'ssh', 'OpenSSH_9.6', 'tcp', 'open', '2026-11-01', '2026-11-01')")
+    con.execute("INSERT INTO findings VALUES (1, 1, '192.168.1.3', 'exposure', 'high', 'Open exploit reachable', 'nmap', 'svc', 'patch', 'disruption', 'CVE-9999-0001', 8.1, 1, '2026-11-01', NULL)")
+    con.commit()
+    con.close()
+    return {"scan_id": 1}
+
+
+def make_sf_db(path: Path) -> dict:
+    con = sqlite3.connect(path)
+    for ddl in SF_DDL:
+        con.execute(ddl)
+    con.execute("INSERT INTO datasets VALUES (1, 'terrain-cells', 1, 'last-write-wins', '2026-11-01')")
+    for seq in range(1, 6):
+        con.execute(
+            "INSERT INTO operation_journal VALUES (?, 1, ?, 'nodeA', ?, 0, 1, ?, NULL, '2026-11-01 10:00:00', NULL)",
+            (seq, f"cell-{seq}", seq, b"payload"),
+        )
+    con.execute("INSERT INTO replication_checkpoints VALUES (1, 'nodeB', 1, 4, 4, '2026-11-01 10:01:00')")
+    con.execute("INSERT INTO replication_checkpoints VALUES (2, 'nodeC', 1, 3, 3, '2026-11-01 10:01:00')")
+    con.execute("INSERT INTO conflicts VALUES (1, 'op-x', 'op-x-local', 'op-x-remote', 0, '2026-11-01 10:02:00', NULL, NULL)")
+    con.commit()
+    con.close()
+    return {"peer_lagging": "nodeC", "lag": 2}

pyrobostudio_sidecar-0.1.0/src/pyrobostudio_sidecar/lerobot.py

@@ -0,0 +1,115 @@
+"""LeRobotDataset v3.0 Parquet adapter — read-only.
+
+Layout per docs/research/adapter-schemas.md §2 and verified against the
+PyRoboFrames writer (lerobot.py). A directory without meta/info.json is
+rejected rather than guessed (mirrors PyRoboFrames Rust reader behavior).
+"""
+import json
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+INFO_REQUIRED = ["codebase_version", "robot_type", "fps", "total_episodes", "total_frames", "features"]
+
+
+class DatasetError(ValueError):
+    pass
+
+
+class LeRobotAdapter:
+    def __init__(self, root: Path) -> None:
+        self.root = root
+        info_path = root / "meta" / "info.json"
+        if not info_path.exists():
+            raise DatasetError(f"{root}: not a LeRobotDataset v3.0 (missing meta/info.json)")
+        info = json.loads(info_path.read_text())
+        missing = [k for k in INFO_REQUIRED if k not in info]
+        if missing:
+            raise DatasetError(f"{root}: meta/info.json missing keys {missing}")
+        if info["codebase_version"] != "v3.0":
+            raise DatasetError(f"{root}: codebase_version {info['codebase_version']!r} != v3.0")
+        self.info = info
+
+    def dataset_id(self) -> str:
+        return self.root.name
+
+    def episodes(self) -> list[dict]:
+        out: list[dict] = []
+        for chunk in sorted((self.root / "meta" / "episodes").glob("chunk-*/file-*.parquet")):
+            table = pq.read_table(chunk)
+            cols = {name: table.column(name).to_pylist() for name in table.column_names}
+            for i in range(table.num_rows):
+                out.append(
+                    {
+                        "episode_index": cols["episode_index"][i],
+                        "length": cols["length"][i],
+                        "dataset_from_index": cols["dataset_from_index"][i],
+                        "dataset_to_index": cols["dataset_to_index"][i],
+                        "data/chunk_index": cols["data/chunk_index"][i],
+                        "data/file_index": cols["data/file_index"][i],
+                    }
+                )
+        return out
+
+    def features(self) -> dict:
+        return self.info["features"]
+
+    def fps(self) -> int:
+        return int(self.info["fps"])
+
+    def steps(self, episode_index: int, max_steps: int = 64) -> list[dict]:
+        eps = self.episodes()
+        ep = next((e for e in eps if e["episode_index"] == episode_index), None)
+        if ep is None:
+            raise KeyError(f"unknown episode {episode_index}")
+        from_idx = ep["dataset_from_index"]
+        to_idx = min(ep["dataset_to_index"], from_idx + max_steps)
+        chunk = self.root / "data" / f"chunk-{ep['data/chunk_index']:03d}" / f"file-{ep['data/file_index']:03d}.parquet"
+        table = pq.read_table(chunk)
+        stats = self.stats()
+        cols = {name: table.column(name) for name in table.column_names}
+        # Shards store one row per step; each column value is the step's fixed-size vector.
+        def vec(name: str, row_i: int) -> list:
+            return cols[name][row_i].as_py()
+
+        out: list[dict] = []
+        for gidx in range(from_idx, to_idx):
+            row_i = gidx  # one row per step in this layout
+            if row_i >= table.num_rows:
+                raise DatasetError(f"{self.root}: data shard has {table.num_rows} rows, need row {row_i}")
+            out.append(
+                {
+                    "globalStep": gidx,
+                    "episode_index": episode_index,
+                    "features": {
+                        name: vec(name, row_i) for name in cols
+                    },
+                    "stats": {name: stats.get(name, {}) for name in cols},
+                }
+            )
+        return out
+
+    def stats(self) -> dict:
+        stats_path = self.root / "meta" / "stats.json"
+        if not stats_path.exists():
+            raise DatasetError(f"{self.root}: missing meta/stats.json")
+        return json.loads(stats_path.read_text())
+
+    def summary(self) -> dict:
+        return {
+            "dataset_id": self.dataset_id(),
+            "codebase_version": self.info["codebase_version"],
+            "robot_type": self.info.get("robot_type"),
+            "fps": self.fps(),
+            "total_episodes": self.info["total_episodes"],
+            "total_frames": self.info["total_frames"],
+            "features": {name: f["shape"] for name, f in self.info["features"].items()},
+        }
+
+    def provenance(self) -> dict:
+        versions = {}
+        for name in (".versions.json", "manifest.json"):
+            p = self.root / name
+            if p.exists():
+                versions[name] = json.loads(p.read_text())
+        return versions

pyrobostudio_sidecar-0.1.0/src/pyrobostudio_sidecar/make_fixture.py

@@ -0,0 +1,255 @@
+"""Generate a deterministic MCAP fixture plus graph/event metadata for tests.
+Run: uv run python -m pyrobostudio_sidecar.make_fixture
+Output: sidecar/fixtures/sample_session.mcap, sample_events.json
+"""
+import json
+import math
+from pathlib import Path
+from mcap.writer import Writer
+FIXTURE_DIR = Path(__file__).parent.parent.parent / "fixtures"
+SPAN_NS = 10_000_000_000
+STEP_NS = 200_000_000
+CMDVEL_SCHEMA = "geometry_msgs/msg/Twist"
+SCAN_SCHEMA = "sensor_msgs/msg/LaserScan"
+def make_fixture() -> None:
+    FIXTURE_DIR.mkdir(exist_ok=True)
+    path = FIXTURE_DIR / "sample_session.mcap"
+    with open(path, "wb") as fp:
+        w = Writer(fp)
+        w.start(profile="ros2")
+        schema_cmdvel = w.register_schema(CMDVEL_SCHEMA, "jsonschema", b"{}")
+        schema_scan = w.register_schema(SCAN_SCHEMA, "jsonschema", b"{}")
+        ch_vel = w.register_channel("/robot1/cmd_vel", message_encoding="json", schema_id=schema_cmdvel)
+        ch_scan = w.register_channel("/robot1/scan", message_encoding="json", schema_id=schema_scan)
+        for i in range(SPAN_NS // STEP_NS):
+            t = i * STEP_NS
+            gap = 3 <= i <= 5
+            if not gap:
+                x = 1.0 + math.sin(i / 5) * 0.2
+                payload = json.dumps(
+                    {"linear": {"x": round(x, 3), "y": 0.0, "z": 0.0},
+                     "angular": {"x": 0.0, "y": 0.0, "z": round(math.sin(i / 7), 3)}}
+                ).encode()
+                w.add_message(ch_vel, log_time=t, publish_time=t, data=payload)
+            if i % 5 == 0:
+                payload = json.dumps(
+                    {"capacity": 16, "ranges": [round(0.4 + 0.2 * abs(math.cos(t / 1e9)), 2)] * 10}
+                ).encode()
+                w.add_message(ch_scan, log_time=t, publish_time=t, data=payload)
+        w.finish()
+    events = [
+        {
+            "id": "ev-gap",
+            "sessionId": "sample_session",
+            "timestampNs": 1_000_000_000,
+            "kind": "communication_gap",
+            "label": "cmd_vel gap 0.8s (i=3..5)",
+            "severity": "warn",
+        },
+        {
+            "id": "ev-scan-anomaly",
+            "sessionId": "sample_session",
+            "timestampNs": 6_000_000_000,
+            "kind": "scan_range_spike",
+            "label": "scan ranges spike 2.0x",
+            "severity": "error",
+        },
+        {
+            "id": "ev-recovered",
+            "sessionId": "sample_session",
+            "timestampNs": 9_000_000_000,
+            "kind": "recovery",
+            "label": "teleop resumed",
+            "severity": "info",
+        },
+    ]
+    (FIXTURE_DIR / "sample_events.json").write_text(json.dumps(events, indent=2))
+    graph = {
+        "nodes": [
+            {"id": "n/robot1/teleop", "ns": "/robot1", "name": "teleop", "kind": "node"},
+            {"id": "n/robot1/controller", "ns": "/robot1", "name": "controller", "kind": "node"},
+            {"id": "n/robot1/lidar", "ns": "/robot1", "name": "lidar", "kind": "node"},
+        ],
+        "topics": [
+            {"id": "t/robot1/cmd_vel", "name": "/robot1/cmd_vel", "msgType": CMDVEL_SCHEMA, "pubCount": 1, "subCount": 1, "qos": {"summary": "best_effort, depth 5 (fixture metadata)"}},
+            {"id": "t/robot1/scan", "name": "/robot1/scan", "msgType": SCAN_SCHEMA, "pubCount": 1, "subCount": 1, "qos": {"summary": "best_effort, depth 10 (fixture metadata)"}},
+        ],
+        "edges": [
+            {"id": "e1", "nodeId": "n/robot1/teleop", "topicId": "t/robot1/cmd_vel", "direction": "pub", "qosCompat": "ok"},
+            {"id": "e2", "nodeId": "n/robot1/controller", "topicId": "t/robot1/cmd_vel", "direction": "sub", "qosCompat": "ok"},
+            {"id": "e3", "nodeId": "n/robot1/lidar", "topicId": "t/robot1/scan", "direction": "pub", "qosCompat": "ok"},
+            {"id": "e4", "nodeId": "n/robot1/controller", "topicId": "t/robot1/scan", "direction": "sub", "qosCompat": "ok"},
+        ],
+        "activity": [],
+    }
+    (FIXTURE_DIR / "sample_graph.json").write_text(json.dumps(graph, indent=2))
+    tf = {
+        "frames": [
+            {"frameId": "odom", "authority": "sample_session"},
+            {"frameId": "base_link", "parentId": "odom", "translation": [1.0, 0.0, 0.0], "rotation": [0, 0, 0, 1]},
+            {"frameId": "laser", "parentId": "base_link", "translation": [0.2, 0.0, 0.3], "rotation": [0, 0, 0, 1]},
+        ]
+    }
+    (FIXTURE_DIR / "sample_tf.json").write_text(json.dumps(tf, indent=2))
+    print(f"wrote {path}, events, graph, tf")
+def make_repo_fixtures() -> None:
+    """Phase 4 adapter fixtures: ros2bag .db3, lerobot dataset, tracks JSON, world_spec.json, sqlite stores."""
+    from pyrobostudio_sidecar.ros2bag import write_db3_fixture
+    from pyrobostudio_sidecar.fixtures_env import make_ni_db, make_sf_db
+
+    for stale in [
+        FIXTURE_DIR / "sample_session.db3",
+        FIXTURE_DIR / "sample_tracks.json",
+        FIXTURE_DIR / "pynetworkintel.db",
+        FIXTURE_DIR / "syncfleet.db",
+    ]:
+        stale.unlink(missing_ok=True)
+    import numpy as np
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    cmd_vel = {"linear": {"x": 0.5, "y": 0.0, "z": 0.0}, "angular": {"x": 0.0, "y": 0.0, "z": 0.1}}
+    scan = {
+        "header": {"stamp": {"sec": 0, "nanosec": 0}, "frame_id": "laser"},
+        "angle_min": 0.0, "angle_max": 1.0, "angle_increment": 0.01,
+        "time_increment": 0.0, "scan_time": 0.0, "range_min": 0.2, "range_max": 10.0,
+        "ranges": [0.4, 0.6, 0.8], "intensities": [1.0, 1.0, 1.0],
+    }
+    odom = {
+        "header": {"stamp": {"sec": 0, "nanosec": 0}, "frame_id": "odom"},
+        "child_frame_id": "base_link",
+        "pose": {"pose": {"position": {"x": 1.0, "y": 0.0, "z": 0.0},
+                          "orientation": {"x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0}},
+                 "covariance": [0.0] * 36},
+        "twist": {"twist": {"linear": {"x": 0.5, "y": 0.0, "z": 0.0},
+                            "angular": {"x": 0.0, "y": 0.0, "z": 0.1}},
+                  "covariance": [0.0] * 36},
+    }
+    db3 = FIXTURE_DIR / "sample_session.db3"
+    write_db3_fixture(
+        db3,
+        topics={
+            "/robot1/cmd_vel": "geometry_msgs/msg/Twist",
+            "/robot1/scan": "sensor_msgs/msg/LaserScan",
+            "/odom": "nav_msgs/msg/Odometry",
+        },
+        timed_messages={
+            "/robot1/cmd_vel": [(0, cmd_vel), (200_000_000, cmd_vel)],
+            "/robot1/scan": [(100_000_000, scan)],
+            "/odom": [(50_000_000, odom)],
+        },
+    )
+    lc = FIXTURE_DIR / "warehouse_demo"
+    (lc / "meta" / "episodes" / "chunk-000").mkdir(parents=True, exist_ok=True)
+    (lc / "data" / "chunk-000").mkdir(parents=True, exist_ok=True)
+    flat = [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]]
+    info = {
+        "codebase_version": "v3.0", "robot_type": "warehouse_bot", "fps": 10,
+        "total_episodes": 2, "total_frames": 3, "chunks_size": 1000,
+        "data_path": "data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet",
+        "video_path": None, "video_codec": None, "video_crf": None,
+        "features": {"observation.state": {"dtype": "float32", "shape": [3]},
+                     "action": {"dtype": "float32", "shape": [3]}},
+    }
+    (lc / "meta" / "info.json").write_text(json.dumps(info))
+    eps = pa.table({
+        "episode_index": pa.array([0, 1], pa.int64()),
+        "length": pa.array([2, 1], pa.int64()),
+        "dataset_from_index": pa.array([0, 2], pa.int64()),
+        "dataset_to_index": pa.array([2, 3], pa.int64()),
+        "data/chunk_index": pa.array([0, 0], pa.int64()),
+        "data/file_index": pa.array([0, 0], pa.int64()),
+    })
+    pq.write_table(eps, lc / "meta" / "episodes" / "chunk-000" / "file-000.parquet")
+    d = 3
+    table = pa.table({
+        "observation.state": pa.FixedSizeListArray.from_arrays(np.array(flat, dtype=np.float32).ravel(), d),
+        "action": pa.FixedSizeListArray.from_arrays(np.array([[x * 0.5 for x in s] for s in flat], dtype=np.float32).ravel(), d),
+    })
+    pq.write_table(table, lc / "data" / "chunk-000" / "file-000.parquet")
+    (lc / "meta" / "stats.json").write_text(json.dumps({
+        "observation.state": {"mean": [0.0] * d, "std": [1.0] * d, "min": [0.0] * d, "max": [1.0] * d},
+        "action": {"mean": [0.0] * d, "std": [0.5] * d, "min": [0.0] * d, "max": [0.5] * d},
+    }))
+    (lc / ".versions.json").write_text(json.dumps({"versions": [{"tag": "v1", "created": "2026-11-01", "episodes": 2}], "current": "v1"}))
+    tracks = {
+        "schema_version": "1",
+        "clip_id": "clip-warehouse-1",
+        "max_age": 3,
+        "frames": [
+            {"frame": 0, "timestampNs": 0, "tracks": [
+                {"track_id": 1, "bbox": [10, 10, 60, 120], "class_id": 0, "confidence": 0.93,
+                 "time_since_update": 0, "hit_streak": 4, "is_confirmed": True},
+                {"track_id": 2, "bbox": [200, 80, 260, 190], "class_id": 1, "confidence": 0.44,
+                 "time_since_update": 2, "hit_streak": 1, "is_confirmed": False}]},
+            {"frame": 1, "timestampNs": 200_000_000, "tracks": [
+                {"track_id": 1, "bbox": [12, 10, 64, 120], "class_id": 0, "confidence": 0.91,
+                 "time_since_update": 0, "hit_streak": 5, "is_confirmed": True}]},
+        ],
+    }
+    (FIXTURE_DIR / "sample_tracks.json").write_text(json.dumps(tracks, indent=2))
+    world_dir = FIXTURE_DIR / "warehouse_sim"
+    world_dir.mkdir(exist_ok=True)
+    world_spec = {
+        "metadata": {"seed": "66", "name": "warehouse_sim"},
+        "scene_bounds_min": [-50.0, -50.0, 0.0],
+        "scene_bounds_max": [50.0, 50.0, 40.0],
+        "lighting": {"sun_intensity": 1.2, "sun_angle_elevation": 55.0, "sun_angle_azimuth": 200.0,
+                     "ambient_intensity": 0.5, "shadow_distance": 300},
+        "weather": {"rain_intensity": 0.0, "cloud_coverage": 0.4, "fog_density": 0.05,
+                    "fog_color_rgb": [0.8, 0.8, 0.9], "fog_distance": 900, "wind_speed": 0.8,
+                    "temperature_celsius": 21},
+        "time_of_day": {"hour": 10, "minute": 0, "day_of_year": 1, "season": "summer"},
+        "rendering": {"profile": "edge", "resolution_width": 960, "resolution_height": 540, "fps": 30,
+                      "ray_tracing": False, "motion_blur": False, "depth_of_field": False},
+        "sensors": {"rgb_enabled": True, "depth_enabled": True, "lidar_enabled": True, "thermal_enabled": False,
+                    "lidar_channels": 16, "lidar_range_max": 100, "save_to_disk": True,
+                    "output_format_rgb": "png", "output_format_depth": "npy", "output_format_lidar": "pcd"},
+        "objects": [
+            {"id": "crate_a", "name": "crateA", "type": "crate", "position": [2, 1, 0], "rotation": [0, 0, 0],
+             "scale": [1, 1, 1], "material": "wood", "physics_enabled": True},
+            {"id": "shelf_1", "name": "shelf", "type": "shelf", "position": [-6, 0, 0], "rotation": [0, 0, 90],
+             "scale": [2, 1, 3], "material": "metal", "physics_enabled": True},
+        ],
+    }
+    (world_dir / "world_spec.json").write_text(json.dumps(world_spec, indent=2))
+    make_ni_db(FIXTURE_DIR / "pynetworkintel.db")
+    make_sf_db(FIXTURE_DIR / "syncfleet.db")
+    print(f"wrote adapter fixtures in {FIXTURE_DIR}: sample_session.db3, warehouse_demo/, sample_tracks.json, warehouse_sim/, pynetworkintel.db, syncfleet.db")
+
+def make_mission_manifest() -> None:
+    """mission.json v1 joining the adapter fixtures with real sha256 hashes."""
+    import hashlib
+
+    from pyrobostudio_sidecar.mission import sha256_of
+
+    def h(name: str) -> str:
+        return sha256_of(FIXTURE_DIR / name)
+
+    manifest = {
+        "schema_version": "1",
+        "mission_id": "mission-warehouse-001",
+        "run_id": "run-2026-11-04-a",
+        "robots": ["robot1", "robot2"],
+        "time_base": {"domain": "session_ns", "start_ns": 0, "end_ns": 10_000_000_000},
+        "artifacts": [
+            {"kind": "rosbag", "id": "sample_session", "uri": "sample_session.mcap", "sha256": h("sample_session.mcap"), "origin": "recorded"},
+            {"kind": "rosbag_db3", "id": "sample_session_db3", "uri": "sample_session.db3", "sha256": h("sample_session.db3"), "origin": "recorded"},
+            {"kind": "vision_tracks", "id": "clip-warehouse-1", "uri": "sample_tracks.json", "sha256": h("sample_tracks.json"), "origin": "recorded"},
+            {"kind": "world_spec", "id": "warehouse_sim", "uri": "warehouse_sim/world_spec.json", "sha256": h("warehouse_sim/world_spec.json"), "origin": "simulated"},
+            {"kind": "networkintel", "id": "pynetworkintel", "uri": "pynetworkintel.db", "sha256": h("pynetworkintel.db"), "origin": "simulated"},
+            {"kind": "syncfleet", "id": "syncfleet", "uri": "syncfleet.db", "sha256": h("syncfleet.db"), "origin": "simulated"},
+        ],
+        "events": [
+            {"id": "ev-gap", "timestamp_ns": 1_000_000_000, "kind": "communication_gap", "label": "cmd_vel gap 0.8s (i=3..5)", "severity": "warn", "artifact": "sample_session"},
+            {"id": "ev-scan-anomaly", "timestamp_ns": 6_000_000_000, "kind": "scan_range_spike", "label": "scan ranges spike 2.0x", "severity": "error", "artifact": "sample_session"},
+            {"id": "ev-recovered", "timestamp_ns": 9_000_000_000, "kind": "recovery", "label": "teleop resumed", "severity": "info", "artifact": "sample_session"},
+        ],
+    }
+    (FIXTURE_DIR / "mission_warehouse.json").write_text(json.dumps(manifest, indent=2))
+    print(f"wrote {FIXTURE_DIR / 'mission_warehouse.json'}")
+
+
+if __name__ == "__main__":
+    make_fixture()
+    make_repo_fixtures()
+    make_mission_manifest()

pyrobostudio_sidecar-0.1.0/src/pyrobostudio_sidecar/mission.py

@@ -0,0 +1,85 @@
+"""Mission manifest v1 (competitive-analysis Gap 1 MVP).
+
+A versioned mission.json joins PyRobo* artifacts (bags, tracks, world specs,
+fleet stores) under one mission/run identity with real sha256 hashes and a
+shared time base. Read-only; served from sidecar/fixtures.
+"""
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+REQUIRED_TOP = {"schema_version", "mission_id", "run_id", "robots", "time_base", "artifacts", "events"}
+REQUIRED_ARTIFACT = {"kind", "id", "uri", "sha256", "origin"}
+KNOWN_KINDS = {"rosbag", "rosbag_db3", "vision_tracks", "world_spec", "networkintel", "syncfleet", "terrain"}
+KNOWN_ORIGINS = {"live", "recorded", "simulated", "derived"}
+
+
+class MissionError(ValueError):
+    pass
+
+
+def sha256_of(path: Path) -> str:
+    h = hashlib.sha256()
+    h.update(path.read_bytes())
+    return h.hexdigest()
+
+
+def validate_manifest(data: dict[str, Any], base_dir: Path) -> dict[str, Any]:
+    missing = REQUIRED_TOP - set(data)
+    if missing:
+        raise MissionError(f"manifest missing keys {sorted(missing)}")
+    if data["schema_version"] != "1":
+        raise MissionError(f"unsupported manifest schema_version {data['schema_version']!r}")
+    tb = data["time_base"]
+    if not isinstance(tb, dict) or not {"domain", "start_ns", "end_ns"} <= set(tb):
+        raise MissionError("time_base must have domain/start_ns/end_ns")
+    if tb["end_ns"] <= tb["start_ns"]:
+        raise MissionError("time_base end_ns must be > start_ns")
+    seen: set[str] = set()
+    for art in data["artifacts"]:
+        miss = REQUIRED_ARTIFACT - set(art)
+        if miss:
+            raise MissionError(f"artifact missing keys {sorted(miss)}")
+        if art["kind"] not in KNOWN_KINDS:
+            raise MissionError(f"unknown artifact kind {art['kind']!r}")
+        if art["origin"] not in KNOWN_ORIGINS:
+            raise MissionError(f"unknown artifact origin {art['origin']!r}")
+        if art["id"] in seen:
+            raise MissionError(f"duplicate artifact id {art['id']!r}")
+        seen.add(art["id"])
+        p = base_dir / art["uri"]
+        if not p.exists():
+            raise MissionError(f"artifact uri not found: {art['uri']}")
+        actual = sha256_of(p)
+        if actual != art["sha256"]:
+            raise MissionError(f"artifact {art['id']}: sha256 mismatch (manifest stale)")
+    for ev in data["events"]:
+        if not {"id", "timestamp_ns", "kind", "label", "severity"} <= set(ev):
+            raise MissionError(f"event missing keys: {ev}")
+        if ev["severity"] not in {"info", "warn", "error"}:
+            raise MissionError(f"event {ev['id']}: bad severity {ev['severity']!r}")
+        if not tb["start_ns"] <= ev["timestamp_ns"] <= tb["end_ns"]:
+            raise MissionError(f"event {ev['id']}: timestamp outside mission time base")
+    return data
+
+
+def load_manifest(path: Path) -> dict[str, Any]:
+    data = json.loads(path.read_text())
+    return validate_manifest(data, path.parent)
+
+
+def mission_summary(data: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "missionId": data["mission_id"],
+        "runId": data["run_id"],
+        "robots": data["robots"],
+        "artifactCount": len(data["artifacts"]),
+        "eventCount": len(data["events"]),
+        "timeBase": data["time_base"],
+    }
+
+
+def manifest_out(data: dict[str, Any]) -> dict[str, Any]:
+    arts = [{**a, "sha256Short": a["sha256"][:12]} for a in data["artifacts"]]
+    return {**data, "artifacts": arts}