agenticros 0.0.1 → 0.1.1

package/runtime/packages/core/src/transport/zenoh/adapter.ts

@@ -0,0 +1,357 @@
+import type { RosTransport } from "../transport.js";
+import type {
+  ConnectionStatus,
+  ConnectionHandler,
+  Subscription,
+  PublishOptions,
+  SubscribeOptions,
+  ServiceCallOptions,
+  ServiceCallResult,
+  ActionGoalOptions,
+  ActionResult,
+  TopicInfo,
+  ServiceInfo,
+  ActionInfo,
+  MessageHandler,
+} from "../types.js";
+import { Session, Config, Locality, Subscriber, type Sample } from "@eclipse-zenoh/zenoh-ts";
+import { rosTopicToZenohKey, zenohKeyToRosTopic, type ZenohKeyFormat } from "./keys.js";
+import { encodeCdr, decodeCdr, isCdrTypeSupported } from "./cdr.js";
+
+export interface ZenohAdapterConfig {
+  routerEndpoint: string;
+  domainId?: number;
+  /** "ros2dds" for zenoh-bridge-ros2dds, "rmw_zenoh" for ROS2 with Zenoh RMW */
+  keyFormat?: ZenohKeyFormat;
+  /** When ros2dds bridge uses a non-"/" namespace, set to the same value (e.g. "/bot1"). */
+  bridgeNamespace?: string;
+}
+
+/**
+ * Zenoh transport adapter (Mode D).
+ * Connects to a Zenoh router via zenoh-ts (WebSocket to zenoh-plugin-remote-api).
+ * Uses rmw_zenoh key mapping and CDR payloads for ROS 2 compatibility.
+ */
+export class ZenohTransport implements RosTransport {
+  private config: ZenohAdapterConfig;
+  private session: Session | null = null;
+  private status: ConnectionStatus = "disconnected";
+  private connectionHandlers: Set<ConnectionHandler> = new Set();
+  private subscribers: Map<string, { undeclare: () => Promise<void> }> = new Map();
+  /** Serialize Session.open/close so two connect()s never open parallel WebSockets to remote-api. */
+  private sessionOpQueue: Promise<void> = Promise.resolve();
+  /** Serialize listTopics so overlapping tool calls do not undeclare each other's subscribers. */
+  private listTopicsOpQueue: Promise<TopicInfo[]> = Promise.resolve([]);
+
+  constructor(config: ZenohAdapterConfig) {
+    this.config = {
+      domainId: 0,
+      keyFormat: "ros2dds",
+      ...config,
+    };
+    this.publish = this.publish.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.subscribeAsync = this.subscribeAsync.bind(this);
+    this.getStatus = this.getStatus.bind(this);
+    this.connect = this.connect.bind(this);
+    this.disconnect = this.disconnect.bind(this);
+  }
+
+  private setStatus(s: ConnectionStatus): void {
+    if (this.status === s) return;
+    this.status = s;
+    this.connectionHandlers.forEach((h) => h(s));
+  }
+
+  private domainId(): number {
+    return this.config.domainId ?? 0;
+  }
+
+  private keyFormat(): ZenohKeyFormat {
+    return this.config.keyFormat ?? "ros2dds";
+  }
+
+  private key(topic: string): string {
+    return rosTopicToZenohKey(topic, this.domainId(), this.keyFormat(), this.config.bridgeNamespace);
+  }
+
+  private enqueueSessionOp(fn: () => Promise<void>): Promise<void> {
+    const next = this.sessionOpQueue.then(fn, fn);
+    this.sessionOpQueue = next.catch(() => {});
+    return next;
+  }
+
+  async connect(): Promise<void> {
+    return this.enqueueSessionOp(async () => {
+      if (this.session && !this.session.isClosed()) return;
+      this.setStatus("connecting");
+      const locator = (this.config.routerEndpoint ?? "").trim();
+      if (!locator) {
+        this.setStatus("disconnected");
+        throw new Error(
+          "Zenoh router endpoint is empty. Set zenoh.routerEndpoint in config (e.g. ws://localhost:10000). See docs/zenoh-agenticros.md.",
+        );
+      }
+      if (!/^wss?:\/\//i.test(locator)) {
+        this.setStatus("disconnected");
+        throw new Error(
+          `Zenoh router endpoint must be a WebSocket URL (ws:// or wss://). Got: "${locator}". Use e.g. ws://localhost:10000 (zenoh-plugin-remote-api).`,
+        );
+      }
+      try {
+        const config = new Config(locator);
+        this.session = await Session.open(config);
+        this.setStatus("connected");
+        console.warn(`[AgenticROS] Zenoh connected to ${locator}`);
+      } catch (e) {
+        this.setStatus("disconnected");
+        const msg = e instanceof Error ? e.message : String(e);
+        if (/invalid url|invalid uri/i.test(msg)) {
+          throw new Error(
+            `Zenoh endpoint "${locator}" is not a valid URL. Use a WebSocket URL, e.g. ws://localhost:10000.`,
+          );
+        }
+        console.error(`[AgenticROS] Zenoh connection failed to ${locator}:`, e);
+        throw e;
+      }
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    return this.enqueueSessionOp(async () => {
+      for (const [, sub] of this.subscribers) {
+        await sub.undeclare();
+      }
+      this.subscribers.clear();
+      if (this.session) {
+        await this.session.close();
+        this.session = null;
+      }
+      this.setStatus("disconnected");
+    });
+  }
+
+  getStatus(): ConnectionStatus {
+    return this.session && !this.session.isClosed() ? "connected" : this.status;
+  }
+
+  onConnection(handler: ConnectionHandler): () => void {
+    this.connectionHandlers.add(handler);
+    return () => this.connectionHandlers.delete(handler);
+  }
+
+  publish(options: PublishOptions): Promise<void> {
+    if (this == null) throw new Error("Zenoh transport not connected");
+    const s = this.session;
+    if (!s || s.isClosed()) {
+      throw new Error("Zenoh transport not connected");
+    }
+    // Normalize cmd_vel: /<uuid>/cmd_vel → /robot<uuid-no-dashes>/cmd_vel so bridge/subscribers see the robot-prefixed topic (robot often expects UUID without dashes)
+    const topicRaw = (options.topic ?? "").trim();
+    const cmdVelMatch = topicRaw.match(/^\/([^/]+)\/cmd_vel$/i);
+    const segment = cmdVelMatch?.[1] ?? "";
+    const topic =
+      cmdVelMatch && !segment.toLowerCase().startsWith("robot")
+        ? `/robot${segment.replace(/-/g, "")}/cmd_vel`
+        : topicRaw;
+    const effectiveTopic = topic || (options.topic ?? "").trim();
+    const key = this.key(effectiveTopic);
+    if (!isCdrTypeSupported(options.type)) {
+      throw new Error(
+        `Zenoh CDR publish not implemented for type: ${options.type}. Supported: geometry_msgs/msg/Twist (Image/CompressedImage are decode-only).`,
+      );
+    }
+    if (!key) {
+      throw new Error(`Zenoh publish: topic is empty (options.topic=${JSON.stringify(options.topic)})`);
+    }
+    const payload = encodeCdr(options.type, options.msg);
+    console.warn(`[AgenticROS] Zenoh publish: key=${key} topic=${effectiveTopic}`);
+    return s.put(key, payload).catch((err: unknown) => {
+      console.error("[AgenticROS] Zenoh put failed:", key, err);
+      throw new Error(`Zenoh put failed: ${err}`);
+    });
+  }
+
+  subscribe(options: SubscribeOptions, handler: MessageHandler): Subscription {
+    if (this == null) throw new Error("Zenoh transport not connected");
+    const s = this.session;
+    if (!s || s.isClosed()) {
+      throw new Error("Zenoh transport not connected");
+    }
+    const key = this.key(options.topic);
+    const type = options.type ?? "geometry_msgs/msg/Twist";
+
+    if (!isCdrTypeSupported(type)) {
+      throw new Error(
+        `Zenoh CDR subscribe not implemented for type: ${type}. Supported: geometry_msgs/msg/Twist, sensor_msgs/msg/Image, sensor_msgs/msg/CompressedImage`,
+      );
+    }
+
+    const subKey = `${options.topic}\0${type}`;
+    const ref: { undeclare: () => Promise<void> } = { undeclare: async () => {} };
+    let decodeErrorLogged = false;
+
+    s.declareSubscriber(key, {
+      allowedOrigin: Locality.ANY,
+      handler: (sample: Sample) => {
+        const payload = sample.payload().toBytes();
+        try {
+          const msg = decodeCdr(type, payload);
+          handler(msg);
+        } catch (e) {
+          if (!decodeErrorLogged) {
+            decodeErrorLogged = true;
+            console.warn("[AgenticROS] Zenoh CDR decode failed for", options.topic, type, e instanceof Error ? e.message : String(e));
+          }
+        }
+      },
+    }).then((sub) => {
+      ref.undeclare = () => sub.undeclare();
+      this.subscribers.set(subKey, ref);
+    });
+
+    return {
+      unsubscribe: () => {
+        const entry = this.subscribers.get(subKey);
+        if (entry) {
+          entry.undeclare().catch(() => {});
+          this.subscribers.delete(subKey);
+        }
+      },
+    };
+  }
+
+  async subscribeAsync(options: SubscribeOptions, handler: MessageHandler): Promise<Subscription> {
+    if (this == null) throw new Error("Zenoh transport not connected");
+    const s = this.session;
+    if (!s || s.isClosed()) {
+      throw new Error("Zenoh transport not connected");
+    }
+    const key = this.key(options.topic);
+    const type = options.type ?? "geometry_msgs/msg/Twist";
+
+    if (!isCdrTypeSupported(type)) {
+      throw new Error(
+        `Zenoh CDR subscribe not implemented for type: ${type}. Supported: geometry_msgs/msg/Twist, sensor_msgs/msg/Image, sensor_msgs/msg/CompressedImage`,
+      );
+    }
+
+    const subKey = `${options.topic}\0${type}`;
+    let decodeErrorLogged = false;
+    const sub = await s.declareSubscriber(key, {
+      allowedOrigin: Locality.ANY,
+      handler: (sample: Sample) => {
+        const payload = sample.payload().toBytes();
+        try {
+          const msg = decodeCdr(type, payload);
+          handler(msg);
+        } catch (e) {
+          if (!decodeErrorLogged) {
+            decodeErrorLogged = true;
+            console.warn("[AgenticROS] Zenoh CDR decode failed for", options.topic, type, e instanceof Error ? e.message : String(e));
+          }
+        }
+      },
+    });
+    this.subscribers.set(subKey, { undeclare: () => sub.undeclare() });
+
+    return {
+      unsubscribe: () => {
+        const entry = this.subscribers.get(subKey);
+        if (entry) {
+          entry.undeclare().catch(() => {});
+          this.subscribers.delete(subKey);
+        }
+      },
+    };
+  }
+
+  async callService(_options: ServiceCallOptions): Promise<ServiceCallResult> {
+    return {
+      result: false,
+      values: { error: "Zenoh transport: service call not implemented" },
+    };
+  }
+
+  async sendActionGoal(_options: ActionGoalOptions): Promise<ActionResult> {
+    return {
+      result: false,
+      values: { error: "Zenoh transport: action goal not implemented" },
+    };
+  }
+
+  async cancelActionGoal(_action: string): Promise<void> {
+    // no-op
+  }
+
+  async listTopics(): Promise<TopicInfo[]> {
+    const run = async (): Promise<TopicInfo[]> => {
+      const s = this.session;
+      if (!s || s.isClosed()) {
+        console.warn("[AgenticROS] Zenoh listTopics: not connected");
+        return [];
+      }
+      const keys = new Set<string>();
+      const handler = (sample: Sample) => {
+        keys.add(sample.keyexpr().toString());
+      };
+      // Canon expressions only (`**/*` forbidden → use `*/**`). Do not use bare `**` (whole keyspace).
+      // `*/**` does NOT match single-chunk keys (e.g. zenoh key `cmd_vel` from ROS `/cmd_vel`), so include `*`.
+      const patterns = ["*/**", "*", "camera/**", "**/camera/**"];
+      const subs: Subscriber[] = [];
+      for (const keyexpr of patterns) {
+        try {
+          subs.push(await s.declareSubscriber(keyexpr, { handler, allowedOrigin: Locality.ANY }));
+        } catch (e) {
+          console.warn(
+            "[AgenticROS] Zenoh listTopics: declareSubscriber failed for",
+            keyexpr,
+            e instanceof Error ? e.message : String(e),
+          );
+        }
+      }
+      if (subs.length === 0) {
+        console.warn("[AgenticROS] Zenoh listTopics: no subscribers declared (check key expressions)");
+        return [];
+      }
+      const rawMs = Number.parseInt(process.env.AGENTICROS_ZENOH_LIST_TOPICS_MS ?? "", 10);
+      const sampleMs = Number.isFinite(rawMs) ? Math.min(60_000, Math.max(1000, rawMs)) : 6500;
+      await new Promise((r) => setTimeout(r, sampleMs));
+      await Promise.all(subs.map((sub) => sub.undeclare()));
+      const format = this.keyFormat();
+      const topics = Array.from(keys)
+        .filter((key) => !key.startsWith("@"))
+        .map((key) => ({
+          name: zenohKeyToRosTopic(key, format),
+          type: "unknown",
+        }));
+      if (topics.length > 0) {
+        console.warn(`[AgenticROS] Zenoh listTopics: found ${topics.length} keys (sampled ${sampleMs}ms)`);
+      } else {
+        const ep = (this.config.routerEndpoint ?? "").trim() || "(not configured)";
+        console.warn(
+          "[AgenticROS] Zenoh listTopics: no keys in sampling window — " +
+            `waited ${sampleMs}ms on ${ep}. ` +
+            "If `zenoh subscribe` on another host shows traffic, ensure it uses the **same Zenoh router** as this session: " +
+            "OpenClaw uses **WebSocket to zenoh-plugin-remote-api** (e.g. ws://127.0.0.1:10000), not raw TCP to the robot. " +
+            "A CLI client to tcp/ROBOT_IP:7447 sees the robot's local router; data only appears here if the robot bridge peers to the Mac router you connected to. " +
+            "`subscribe -k '**'` also prints **binary payloads** (garbled text), not topic names — keys are short path-like strings when Zenoh prints them separately. " +
+            "Optional: set AGENTICROS_ZENOH_LIST_TOPICS_MS (ms) to sample longer for low-rate topics.",
+        );
+      }
+      return topics;
+    };
+
+    const next = this.listTopicsOpQueue.then(run, run);
+    this.listTopicsOpQueue = next.catch(() => []);
+    return next;
+  }
+
+  async listServices(): Promise<ServiceInfo[]> {
+    return [];
+  }
+
+  async listActions(): Promise<ActionInfo[]> {
+    return [];
+  }
+}

package/runtime/packages/core/src/transport/zenoh/cdr.ts

@@ -0,0 +1,183 @@
+/**
+ * CDR encode/decode for ROS 2 messages over Zenoh (rmw_zenoh uses CDR payloads).
+ * Supports geometry_msgs/msg/Twist, sensor_msgs/msg/Image, sensor_msgs/msg/CompressedImage.
+ */
+
+import { CdrReader, CdrWriter } from "@foxglove/cdr";
+import { parse } from "@foxglove/rosmsg";
+import { MessageReader } from "@foxglove/rosmsg2-serialization";
+
+/** Normalize type string to "pkg/msg/Type" form. Handles short names (e.g. "Image") and combined forms. */
+function normalizeType(typeStr: string): string {
+  const s = typeStr.trim();
+  if (s.includes("CompressedImage")) return "sensor_msgs/msg/CompressedImage";
+  if (s === "Image" || s.endsWith("/Image") || (s.includes("sensor_msgs") && s.includes("Image"))) {
+    return "sensor_msgs/msg/Image";
+  }
+  const parts = s.split("/");
+  if (parts.length === 3) return s;
+  if (parts.length === 2) return `${parts[0]}/msg/${parts[1]}`;
+  return s;
+}
+
+/** Read std_msgs/Header from current reader offset (used by Image and CompressedImage). */
+function readStdMsgsHeader(reader: CdrReader): Record<string, unknown> {
+  const sec = reader.int32();
+  const nanosec = reader.uint32();
+  const frame_id = reader.string();
+  return {
+    stamp: { sec, nanosec },
+    frame_id,
+  };
+}
+
+/**
+ * `CdrReader` already skips the 4-byte encapsulation header (initial offset 4).
+ * CDR2 **appendable** messages (typical for `sensor_msgs` from CycloneDDS / zenoh-bridge-ros2dds)
+ * include a 4-byte **DHEADER** next; without consuming it, `CompressedImage` / `Image` decode misaligns
+ * and the teleop camera sees no valid frames (timeouts → 503).
+ */
+function createBodyReader(data: Uint8Array): CdrReader {
+  const reader = new CdrReader(new DataView(data.buffer, data.byteOffset, data.byteLength));
+  if (reader.usesDelimiterHeader && !reader.usesMemberHeader) {
+    reader.dHeader();
+  }
+  return reader;
+}
+
+/** Embedded defs so Zenoh samples decode like rviz/ros2 bag (CDR1 / CDR2 / delimited / PL_CDR2). */
+const COMPRESSED_IMAGE_MSG_DEF = `
+std_msgs/msg/Header header
+string format
+uint8[] data
+
+================================================================================
+MSG: std_msgs/msg/Header
+builtin_interfaces/msg/Time stamp
+string frame_id
+
+================================================================================
+MSG: builtin_interfaces/msg/Time
+int32 sec
+uint32 nanosec
+`;
+
+let compressedImageReader: MessageReader | null = null;
+
+function decodeCompressedImageWithFoxglove(data: Uint8Array): Record<string, unknown> {
+  if (!compressedImageReader) {
+    compressedImageReader = new MessageReader(parse(COMPRESSED_IMAGE_MSG_DEF, { ros2: true }));
+  }
+  const msg = compressedImageReader.readMessage<Record<string, unknown>>(data);
+  return {
+    header: msg["header"],
+    format: msg["format"],
+    data: msg["data"],
+  };
+}
+
+function decodeCompressedImageManual(data: Uint8Array): Record<string, unknown> {
+  const reader = createBodyReader(data);
+  const header = readStdMsgsHeader(reader);
+  const format = reader.string();
+  const dataLen = reader.sequenceLength();
+  const payload = reader.uint8Array(dataLen);
+  return {
+    header,
+    format,
+    data: Array.from(payload),
+  };
+}
+
+/**
+ * Encode a ROS 2 message to CDR (little-endian) for the given type.
+ * Supports: geometry_msgs/msg/Twist.
+ */
+export function encodeCdr(typeStr: string, msg: Record<string, unknown>): Uint8Array {
+  const type = normalizeType(typeStr);
+
+  if (type === "geometry_msgs/msg/Twist") {
+    const linear = (msg["linear"] as Record<string, unknown>) ?? {};
+    const angular = (msg["angular"] as Record<string, unknown>) ?? {};
+    // Standard ROS 2 Twist order: linear.x, linear.y, linear.z, angular.x, angular.y, angular.z (CDR LE, 4-byte encapsulation + 6 float64).
+    const buf = new ArrayBuffer(4 + 6 * 8);
+    const view = new DataView(buf);
+    view.setUint32(0, 0x100, true);
+    const vals = [
+      Number(linear["x"] ?? 0),
+      Number(linear["y"] ?? 0),
+      Number(linear["z"] ?? 0),
+      Number(angular["x"] ?? 0),
+      Number(angular["y"] ?? 0),
+      Number(angular["z"] ?? 0),
+    ];
+    for (let i = 0; i < 6; i++) view.setFloat64(4 + i * 8, vals[i], true);
+    return new Uint8Array(buf);
+  }
+
+  throw new Error(`Zenoh CDR encode not implemented for type: ${typeStr}`);
+}
+
+/**
+ * Decode a CDR payload to a plain object for the given type.
+ * Supports: geometry_msgs/msg/Twist.
+ */
+export function decodeCdr(typeStr: string, data: Uint8Array): Record<string, unknown> {
+  const type = normalizeType(typeStr);
+
+  if (type === "geometry_msgs/msg/Twist") {
+    const reader = createBodyReader(data);
+    const linear = {
+      x: reader.float64(),
+      y: reader.float64(),
+      z: reader.float64(),
+    };
+    const angular = {
+      x: reader.float64(),
+      y: reader.float64(),
+      z: reader.float64(),
+    };
+    return { linear, angular };
+  }
+
+  if (type === "sensor_msgs/msg/CompressedImage") {
+    try {
+      return decodeCompressedImageWithFoxglove(data);
+    } catch {
+      return decodeCompressedImageManual(data);
+    }
+  }
+
+  if (type === "sensor_msgs/msg/Image") {
+    const reader = createBodyReader(data);
+    const header = readStdMsgsHeader(reader);
+    const height = reader.uint32();
+    const width = reader.uint32();
+    const encoding = reader.string();
+    const is_bigendian = reader.uint8();
+    const step = reader.uint32();
+    const dataLen = reader.sequenceLength();
+    const payload = reader.uint8Array(dataLen);
+    return {
+      header,
+      height,
+      width,
+      encoding,
+      is_bigendian,
+      step,
+      data: Array.from(payload),
+    };
+  }
+
+  throw new Error(`Zenoh CDR decode not implemented for type: ${typeStr}`);
+}
+
+/** Check if we can encode/decode the given type. */
+export function isCdrTypeSupported(typeStr: string): boolean {
+  const type = normalizeType(typeStr);
+  return (
+    type === "geometry_msgs/msg/Twist" ||
+    type === "sensor_msgs/msg/Image" ||
+    type === "sensor_msgs/msg/CompressedImage"
+  );
+}

package/runtime/packages/core/src/transport/zenoh/keys.ts

@@ -0,0 +1,51 @@
+/**
+ * Key format used by the Zenoh router / bridge.
+ * - rmw_zenoh: ROS2 with Zenoh RMW (domain prefix, slashes → %). Example: 0/%robot-uuid%cmd_vel
+ * - ros2dds: zenoh-bridge-ros2dds (no domain prefix, slashes kept). Example: robot-uuid/cmd_vel
+ */
+export type ZenohKeyFormat = "rmw_zenoh" | "ros2dds";
+
+/** Strip optional slashes; empty means bridge default "/" (no extra zenoh prefix). */
+function normalizeBridgeNamespace(ns: string | undefined): string {
+  const t = (ns ?? "").trim();
+  if (!t || t === "/") return "";
+  return t.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
+/**
+ * Map ROS 2 topic name to a Zenoh key expression.
+ * - rmw_zenoh: topic "/robot-uuid/cmd_vel", domainId 0 → "0/%robot-uuid%cmd_vel"
+ * - ros2dds (zenoh-bridge-ros2dds): topic "/robot-uuid/cmd_vel" → "robot-uuid/cmd_vel"
+ *   If the bridge sets plugins.ros2dds.namespace to e.g. "/bot1", pass `bridgeNamespace: "/bot1"`
+ *   so keys become `bot1/robot-uuid/cmd_vel` (matches ros2_name_to_key_expr).
+ */
+export function rosTopicToZenohKey(
+  topic: string,
+  domainId: number,
+  format: ZenohKeyFormat = "ros2dds",
+  bridgeNamespace?: string,
+): string {
+  const normalized = topic.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalized) return format === "rmw_zenoh" ? `${domainId}/` : "";
+  if (format === "rmw_zenoh") {
+    const keyPart = normalized.replace(/\//g, "%");
+    return `${domainId}/%${keyPart}`;
+  }
+  const bridgeNs = normalizeBridgeNamespace(bridgeNamespace);
+  if (!bridgeNs) return normalized;
+  if (normalized === bridgeNs || normalized.startsWith(`${bridgeNs}/`)) return normalized;
+  return `${bridgeNs}/${normalized}`;
+}
+
+/**
+ * Map a Zenoh key expression back to a ROS 2 topic name.
+ * - rmw_zenoh: "0/%robot-uuid%cmd_vel" → "/robot-uuid/cmd_vel"
+ * - ros2dds: "robot-uuid/cmd_vel" → "/robot-uuid/cmd_vel"
+ */
+export function zenohKeyToRosTopic(key: string, format: ZenohKeyFormat = "ros2dds"): string {
+  if (format === "ros2dds") return key.startsWith("/") ? key : `/${key}`;
+  const match = /^\d+\/(.+)$/.exec(key);
+  if (!match) return key;
+  const part = match[1].replace(/%/g, "/");
+  return part.startsWith("/") ? part : `/${part}`;
+}

package/runtime/packages/core/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/runtime/packages/ros-camera/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@agenticros/ros-camera",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Shared ROS2 camera snapshot encoding (sensor_msgs Image / CompressedImage) for AgenticROS adapters",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "fzstd": "^0.1.1",
+    "pngjs": "^7.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "@types/pngjs": "^6.0.5",
+    "typescript": "^5.7.0"
+  },
+  "author": "PlaiPin",
+  "license": "Apache-2.0"
+}

package/runtime/packages/ros-camera/src/index.ts

@@ -0,0 +1,13 @@
+export {
+  ROS_MSG_IMAGE,
+  ROS_MSG_COMPRESSED_IMAGE,
+  bufferAndMimeFromCompressedImageMessage,
+  cameraSnapshotFromPlainMessage,
+  coerceRosImageDataToBuffer,
+  mimeTypeForSnapshotBase64,
+  normalizeDepthImageEncoding,
+  rosBoolField,
+  rosNumericField,
+  rosStringField,
+  type CameraSnapshotPayload,
+} from "./snapshot.js";