agenticros 0.1.18 → 0.2.0

package/dist/util/transport-shorthand.js

@@ -0,0 +1,102 @@
+/**
+ * Parse a `--transport=<shorthand>` flag into the JSON-shaped object the
+ * core resolver expects under `config.robots[i].transport`.
+ *
+ * Shorthand grammar (most-common-case-first):
+ *
+ *     <mode>[:<primary-value>]
+ *
+ *   - `zenoh`                              ⇒ inherit everything from global config.zenoh
+ *   - `zenoh:<routerEndpoint>`             ⇒ override the router endpoint only
+ *   - `rosbridge`                          ⇒ inherit global rosbridge config
+ *   - `rosbridge:<url>`                    ⇒ override rosbridge url
+ *   - `local`                              ⇒ inherit global local config
+ *   - `local:<domainId>`                   ⇒ override DDS domain id (integer ≥ 0)
+ *   - `webrtc`                             ⇒ inherit global webrtc config
+ *   - `webrtc:<signalingUrl>`              ⇒ override signaling url
+ *
+ * Anything more elaborate (multiple sub-fields, custom iceServers, etc.)
+ * should use `--transport-json=...` which is passed straight through to
+ * the core Zod schema. The CLI deliberately doesn't model the full set
+ * of sub-fields — that would couple this layer to every transport
+ * adapter's settings shape. The shorthand exists for the 95% of users
+ * who only want to point one robot at a different router.
+ *
+ * Errors are intentionally specific — they tell the user the exact
+ * accepted forms so they can recover without hunting through docs.
+ */
+const VALID_MODES = ["zenoh", "rosbridge", "local", "webrtc"];
+function isValidMode(s) {
+    return VALID_MODES.includes(s);
+}
+/**
+ * Parse a `--transport=<shorthand>` value. Throws with an actionable
+ * message on malformed input. The returned object is a plain JSON
+ * structure that the core `RobotTransportOverrideSchema` will then
+ * validate at config-load time, so this parser doesn't have to repeat
+ * field-level validation — it only needs to produce well-shaped JSON.
+ */
+export function parseTransportShorthand(raw) {
+    const input = raw.trim();
+    if (!input) {
+        throw new Error("--transport requires a value. Examples: --transport=zenoh, --transport=zenoh:ws://farm:10000, --transport=local:1");
+    }
+    const colon = input.indexOf(":");
+    const modeRaw = (colon < 0 ? input : input.slice(0, colon)).trim().toLowerCase();
+    const valueRaw = colon < 0 ? "" : input.slice(colon + 1).trim();
+    if (!isValidMode(modeRaw)) {
+        throw new Error(`Unknown transport mode "${modeRaw}". Accepted: ${VALID_MODES.join(", ")}. ` +
+            "Example: --transport=zenoh:ws://farm:10000");
+    }
+    switch (modeRaw) {
+        case "zenoh":
+            return valueRaw
+                ? { mode: "zenoh", zenoh: { routerEndpoint: valueRaw } }
+                : { mode: "zenoh" };
+        case "rosbridge":
+            return valueRaw
+                ? { mode: "rosbridge", rosbridge: { url: valueRaw } }
+                : { mode: "rosbridge" };
+        case "local": {
+            if (!valueRaw)
+                return { mode: "local" };
+            const n = Number(valueRaw);
+            if (!Number.isInteger(n) || n < 0) {
+                throw new Error(`--transport=local:<domainId> requires a non-negative integer (got "${valueRaw}"). ` +
+                    "Example: --transport=local:1");
+            }
+            return { mode: "local", local: { domainId: n } };
+        }
+        case "webrtc":
+            return valueRaw
+                ? { mode: "webrtc", webrtc: { signalingUrl: valueRaw } }
+                : { mode: "webrtc" };
+    }
+}
+/**
+ * Validate a raw JSON string passed via `--transport-json`. Returns the
+ * parsed object on success; throws a friendly error on parse failure or
+ * when the JSON doesn't look at all like a transport override (missing
+ * `mode`). Field-level validation is deferred to the core Zod schema at
+ * config-load time — this is just a smoke check so an obviously-wrong
+ * JSON string doesn't slip into the file.
+ */
+export function parseTransportJson(raw) {
+    let obj;
+    try {
+        obj = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`--transport-json: invalid JSON (${e instanceof Error ? e.message : String(e)}). ` +
+            'Example: --transport-json=\'{"mode":"zenoh","zenoh":{"routerEndpoint":"ws://farm:10000"}}\'');
+    }
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+        throw new Error("--transport-json: must be a JSON object, e.g. {\"mode\":\"zenoh\"}");
+    }
+    const mode = obj["mode"];
+    if (typeof mode !== "string" || !isValidMode(mode)) {
+        throw new Error(`--transport-json: missing or invalid "mode" (expected one of ${VALID_MODES.join(", ")}).`);
+    }
+    return obj;
+}
+//# sourceMappingURL=transport-shorthand.js.map

package/dist/util/transport-shorthand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-shorthand.js","sourceRoot":"","sources":["../../src/util/transport-shorthand.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenticros",
-  "version": "0.1.18",
+  "version": "0.2.0",
   "type": "module",
   "description": "AgenticROS - agentic AI for ROS-powered robots. Single CLI to launch real-robot or simulated demos, manage configuration, and inspect status.",
   "keywords": [
@@ -31,6 +31,16 @@
   "engines": {
     "node": ">=20.0.0"
   },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test --test-force-exit \"dist/__tests__/*.test.js\"",
+    "clean": "rm -rf dist runtime tsconfig.tsbuildinfo",
+    "pack:runtime": "node ../../scripts/pack-runtime.mjs",
+    "size:check": "node ../../scripts/check-cli-tarball-size.mjs",
+    "tarball:check": "node ../../scripts/check-cli-tarball-install.mjs",
+    "prepublishOnly": "pnpm run clean && pnpm run build && pnpm run pack:runtime && pnpm run size:check && pnpm run tarball:check"
+  },
   "dependencies": {
     "@inquirer/prompts": "^7.0.0",
     "commander": "^12.1.0",
@@ -49,13 +59,5 @@
     "type": "git",
     "url": "git+https://github.com/agenticros/agenticros.git",
     "directory": "packages/agenticros-cli"
-  },
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist runtime tsconfig.tsbuildinfo",
-    "pack:runtime": "node ../../scripts/pack-runtime.mjs",
-    "size:check": "node ../../scripts/check-cli-tarball-size.mjs",
-    "tarball:check": "node ../../scripts/check-cli-tarball-install.mjs"
   }
-}
+}

package/runtime/BUNDLE.json

@@ -1,5 +1,5 @@
 {
-  "packedAt": "2026-06-09T22:12:21.081Z",
+  "packedAt": "2026-06-12T01:46:30.373Z",
   "repo": "https://github.com/PlaiPin/agenticros",
   "note": "This directory is a snapshot of the agenticros monorepo source. `agenticros init` will copy it to ~/agenticros and run pnpm install + colcon build there.",
   "layout": {

package/runtime/README.md

@@ -25,6 +25,7 @@ With AgenticROS, your robot can describe what it sees, follow intent ("go check
 - **[OpenClaw](https://openclaw.ai)** — Native gateway plugin with ROS 2 tools, commands, a config UI, a teleop web app, and a skill loader. The flagship integration.
 - **[NVIDIA NemoClaw](https://github.com/NVIDIA/NemoClaw)** — Run AgenticROS inside NemoClaw's OpenShell sandbox with policy-enforced egress and managed NVIDIA inference; ROS 2, RealSense, and rosbridge stay on the host while the plugin runs sandboxed.
 - **[Anthropic Claude](https://www.anthropic.com/claude)** — A single MCP server powers **Claude Code** (terminal), **Claude Desktop** (macOS / Windows), and **Claude Dispatch** (iOS, paired to your Mac). Ask Claude what your robot sees, and it answers with a live camera snapshot and depth reading.
+- **[OpenAI Codex CLI](https://developers.openai.com/codex/)** — The same MCP server registers cleanly via `codex mcp add agenticros — node …/packages/agenticros-claude-code/dist/index.js`, or via a `[mcp_servers.agenticros]` entry in `~/.codex/config.toml`. Same 15 tools, same JSON shapes. Setup: [packages/agenticros-claude-code/README.md#codex-cli-openai](packages/agenticros-claude-code/README.md#codex-cli-openai).
 - **[Google Gemini](https://ai.google.dev/)** — Standalone CLI that uses Gemini function calling against the same ROS 2 tools (no MCP required) — ideal for scripting and headless agents.
 
 AgenticROS is built so that new adapters (LangGraph, OpenAI, local models, voice stacks, etc.) can be added without touching the ROS 2 layer. The core transport and tool contract are platform-agnostic; adapters are thin shims that surface those tools to each agent runtime.
@@ -44,6 +45,61 @@ Claude (Code / desktop / Dispatch) → agenticros MCP server → Core → ROS2 r
 Gemini CLI → @agenticros/gemini (function calling) → Core → ROS2 robots
 ```
 
+## A shared mission language for robots
+
+The same tool surface across every adapter — Claude Code, Codex, Gemini, OpenClaw — so two different agents on two different stacks can both speak the same dialect when controlling the same robot. Built around five capabilities.
+
+### Capability manifests — robots advertise *verbs*
+
+Every AgenticROS-enabled robot exposes a typed list of named verbs through `ros2_list_capabilities`: `drive_base`, `take_snapshot`, `measure_depth`, `find_object`, `follow_person`, plus whatever a [skill package](#skills) contributes. The agent plans against the verbs instead of raw ROS 2 topics — and the manifest is shaped to double as an ACP / A2A agent card.
+
+### Mission chaining — `run_mission`
+
+One MCP tool, `run_mission`, executes a declarative step graph. Each step is `{ id, capability, inputs, on_fail }`. Outputs from any step flow into later steps via `{{stepId.outputs.field}}` template references — so a detection wires straight into the next motion command with no glue code:
+
+```json
+{
+  "steps": [
+    { "id": "find",     "capability": "find_object", "inputs": { "target": "chair" } },
+    { "id": "approach", "capability": "drive_base",
+      "inputs": {
+        "linear_x": 0.2,
+        "angular_z": "{{find.outputs.horizontal_offset}}"
+      }
+    }
+  ]
+}
+```
+
+### Natural-language goals
+
+`run_mission` also accepts a `goal` field — plain English. A rule-based, deterministic planner in `@agenticros/core` compiles it into a runnable mission against the robot's capability registry:
+
+- `"take a picture"` → `take_snapshot`
+- `"follow me"` → `follow_person`
+- `"drive forward at 0.3 m/s"` → `drive_base { linear_x: 0.3 }`
+- `"find a chair and drive toward it"` → the two-step compound plan above
+
+No LLM dependency (the planner is a few hundred lines of pattern matching, so the runtime doesn't require Ollama) and no fabricated calls (it only emits capabilities actually in the registry). Uncompilable goals return a clean error with the recognised-verb list so the agent can self-correct.
+
+### Multi-robot fleets
+
+`ros2_list_robots`, `ros2_discover_robots`, and `ros2_find_robots_for({ capability, kind?, online? })` let an agent ask *"give me an AMR that can `follow_person` and is currently online"* and get back a ranked list. The CLI keeps fleet metadata in sync without hand-editing JSON:
+
+```bash
+agenticros robots add my-amr \
+  --kind=amr --sensors=has_realsense,!has_arm \
+  --capabilities=drive_base,take_snapshot,follow_person
+```
+
+On the ROS side, every robot publishes a 1 Hz heartbeat on `<ns>/agenticros/robot_info` so the online filter reflects what's actually reachable. A single mission can route different steps to different robots — *"the AMR finds the box, the arm picks it up"* runs as one mission.
+
+### Cancel + shared transcripts
+
+`mission_cancel({ mission_id })` flips an in-process cancellation token; the runner stops at the next step boundary and marks remaining steps `cancelled`. When the [shared memory backend](#memory-optional) is on, every step is also written to `mission:<id>` in long-term memory, tagged with `step:<status>` and `capability:<id>`. A different agent — different process, different vendor — can `memory_recall` later and reconstruct exactly what happened, so two agents can collaborate on or hand off a mission.
+
+Full architecture + design trade-offs: **[docs/strategy-ai-agents-plus-ros.md](docs/strategy-ai-agents-plus-ros.md)**.
+
 ## Repository layout
 
 - `**packages/core**` — Transport, types, config (Zod). Used by all adapters.
@@ -107,6 +163,7 @@ agenticros up real              # real robot stack
 agenticros up sim-amr           # simulated AMR (Gazebo + RViz, headless on Jetson)
 agenticros up sim-arm           # simulated 6-DOF arm
 agenticros mode <real|sim>      # swap the active config profile (namespace, transport)
+agenticros robots               # list / add / remove robots in the fleet (kind, sensors, capabilities)
 agenticros skills               # list / add / remove AgenticROS skills (see below)
 agenticros doctor               # coloured health check
 agenticros down                 # stop everything we started
@@ -382,7 +439,11 @@ Per-skill behaviour lives under `config.skills.<skillId>` (e.g. `config.skills.f
 
 ### Contract & writing your own skill
 
-A skill is a Node package with `"agenticrosSkill": true` in `package.json` and a `registerSkill(api, config, context)` export from `main`. See **[docs/skills.md](docs/skills.md)** for the full contract and **[agenticros-skill-followme](https://github.com/your-org/agenticros-skill-followme)** as a reference template.
+A skill is a Node package with an `"agenticros": { "id": "..." }` block in `package.json` and a `registerSkill(api, config, context)` export from `main`. Publish it to **[skills.agenticros.com](https://skills.agenticros.com)** so others can install it with `npx agenticros skills install <slug>`. See **[docs/skills.md](docs/skills.md)** for the full contract and **[agenticros-skill-followme](https://github.com/agenticros/agenticros-skill-followme)** as a reference template.
+
+## Strategy & vision
+
+Where AgenticROS is going next — beyond the shared mission language above, the roadmap covers turning capability manifests into agent cards on the wire (WebRTC / A2A so a robot can register itself as an agent in a mesh), an LLM-backed planner behind the existing `compileGoalToMission` contract, the `skills.agenticros.com` marketplace with declarative auto-fetch and in-agent installs, spatial memory, and cross-vendor agent collaboration via ACP / A2A: **[docs/strategy-ai-agents-plus-ros.md](docs/strategy-ai-agents-plus-ros.md)**.
 
 ## License
 

package/runtime/package.json

@@ -9,9 +9,14 @@
     "clean": "pnpm -r exec rm -rf dist tsconfig.tsbuildinfo",
     "lint": "pnpm -r lint",
     "typecheck": "pnpm -r typecheck",
+    "test": "pnpm test:scripts && pnpm -r --workspace-concurrency 1 --if-present test",
+    "test:scripts": "node --test scripts/__tests__/*.test.mjs",
     "mcp:kill": "pkill -f 'node packages/agenticros-claude-code/dist/index.js' || true",
     "sync-skill-tools": "node scripts/sync-skill-tools.mjs",
-    "sync-skill-tools:dry": "node scripts/sync-skill-tools.mjs --dry-run --verbose"
+    "sync-skill-tools:dry": "node scripts/sync-skill-tools.mjs --dry-run --verbose",
+    "refresh:skills": "node scripts/refresh-skill-deps.mjs",
+    "refresh:skills:dry": "node scripts/refresh-skill-deps.mjs --dry-run --verbose",
+    "deploy:plugin": "bash scripts/setup_gateway_plugin.sh --skip-build --no-systemd --no-restart"
   },
   "engines": {
     "node": ">=20.0.0",

package/runtime/packages/agenticros/openclaw.plugin.json

@@ -15,6 +15,12 @@
       "ros2_param_get",
       "ros2_param_set",
       "ros2_list_topics",
+      "ros2_list_capabilities",
+      "ros2_list_robots",
+      "ros2_discover_robots",
+      "ros2_find_robots_for",
+      "run_mission",
+      "mission_cancel",
       "ros2_camera_snapshot",
       "ros2_depth_distance",
       "memory_remember",
@@ -367,7 +373,7 @@
       },
       "skillPaths": {
         "type": "array",
-        "description": "Directories to scan for skill packages (package.json with agenticrosSkill: true).",
+        "description": "Directories to scan for skill packages (package.json with an `agenticros` block).",
         "items": {
           "type": "string"
         },

package/runtime/packages/agenticros/package.json

@@ -14,7 +14,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "node --test --test-force-exit \"dist/__tests__/*.test.js\""
   },
   "openclaw": {
     "extensions": [