agenticros 0.0.1 → 0.1.0

package/runtime/ros2_ws/src/agenticros_msgs/CMakeLists.txt

@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.8)
+project(agenticros_msgs)
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+find_package(ament_cmake REQUIRED)
+find_package(std_msgs REQUIRED)
+find_package(rosidl_default_generators REQUIRED)
+
+find_package(builtin_interfaces REQUIRED)
+find_package(geometry_msgs REQUIRED)
+
+rosidl_generate_interfaces(${PROJECT_NAME}
+  "msg/CapabilityManifest.msg"
+  "srv/GetCapabilities.srv"
+  "srv/FollowMeStart.srv"
+  "srv/FollowMeStop.srv"
+  "srv/FollowMeSetDistance.srv"
+  "srv/FollowMeGetStatus.srv"
+  "srv/FollowMeSetTarget.srv"
+  DEPENDENCIES std_msgs builtin_interfaces geometry_msgs
+)
+
+ament_package()

package/runtime/ros2_ws/src/agenticros_msgs/msg/CapabilityManifest.msg

@@ -0,0 +1,9 @@
+string robot_name
+string robot_namespace
+string[] topic_names
+string[] topic_types
+string[] service_names
+string[] service_types
+string[] action_names
+string[] action_types
+builtin_interfaces/Time stamp

package/runtime/ros2_ws/src/agenticros_msgs/package.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>agenticros_msgs</name>
+  <version>0.0.1</version>
+  <description>Custom ROS2 message and service definitions for AgenticROS</description>
+  <maintainer email="team@plaipin.com">PlaiPin</maintainer>
+  <license>Apache-2.0</license>
+
+  <buildtool_depend>ament_cmake</buildtool_depend>
+  <buildtool_depend>rosidl_default_generators</buildtool_depend>
+
+  <depend>std_msgs</depend>
+  <depend>builtin_interfaces</depend>
+  <depend>geometry_msgs</depend>
+
+  <member_of_group>rosidl_interface_packages</member_of_group>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+</package>

package/runtime/ros2_ws/src/agenticros_msgs/srv/FollowMeGetStatus.srv

@@ -0,0 +1,11 @@
+---
+bool success
+bool enabled
+bool tracking
+float32 target_distance
+float32 current_distance
+int32 target_person_id
+string target_description
+int32 persons_detected
+geometry_msgs/Twist twist
+string error_message

package/runtime/ros2_ws/src/agenticros_msgs/srv/FollowMeSetDistance.srv

@@ -0,0 +1,4 @@
+float32 distance
+---
+bool success
+float32 target_distance

package/runtime/ros2_ws/src/agenticros_msgs/srv/FollowMeSetTarget.srv

@@ -0,0 +1,6 @@
+string description
+---
+bool success
+int32 person_id
+float32 confidence
+string message

package/runtime/ros2_ws/src/agenticros_msgs/srv/FollowMeStart.srv

@@ -0,0 +1,5 @@
+# Start following. Empty target_description = follow closest person.
+string target_description
+---
+bool success
+string message

package/runtime/ros2_ws/src/agenticros_msgs/srv/FollowMeStop.srv

@@ -0,0 +1,3 @@
+---
+bool success
+string message

package/runtime/ros2_ws/src/agenticros_msgs/srv/GetCapabilities.srv

@@ -0,0 +1,5 @@
+string robot_namespace
+---
+agenticros_msgs/CapabilityManifest manifest
+bool success
+string error_message

package/runtime/scripts/activate_workspace.sh

@@ -0,0 +1,285 @@
+#!/bin/bash
+# activate_workspace.sh - Cross-platform workspace activation for AgenticROS
+#
+# DESCRIPTION:
+#   This script sets up the complete development environment for the AgenticROS project.
+#   It supports both Ubuntu (venv + native ROS2) and macOS (mamba + RoboStack).
+#   The script handles platform detection and activates the appropriate environment type.
+#
+# USAGE:
+#   source activate_workspace.sh [env_name] [ros_distro]
+#
+# PARAMETERS:
+#   env_name     Optional. Name of the environment to activate.
+#                Default: ros_env
+#   ros_distro   Optional. ROS2 distribution to use.
+#                Default: humble
+#
+# EXAMPLES:
+#   # Use defaults (ros_env, jazzy)
+#   source scripts/activate_workspace.sh
+#
+#   # Use specific environment name
+#   source scripts/activate_workspace.sh my_ros_env
+#
+#   # Use specific ROS distribution
+#   source scripts/activate_workspace.sh ros_env humble
+#
+# NOTE:
+#   This script must be SOURCED, not executed, to modify the current shell environment.
+
+# Check if script is being sourced
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    echo "Error: This script must be sourced, not executed."
+    echo "Usage: source $(basename ${BASH_SOURCE[0]}) [env_name] [ros_distro]"
+    exit 1
+fi
+
+# Default values
+DEFAULT_ENV_NAME="ros_env"
+DEFAULT_ROS_DISTRO="humble"
+ENV_NAME="${1:-$DEFAULT_ENV_NAME}"
+ROS_DISTRO="${2:-$DEFAULT_ROS_DISTRO}"
+
+# Find the repository root
+REPO_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+ROS2_WS_PATH="$REPO_ROOT/ros2_ws"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging functions
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Platform detection
+detect_platform() {
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        PLATFORM="macos"
+    elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+        if command -v apt &> /dev/null; then
+            PLATFORM="ubuntu"
+        else
+            log_error "Linux platform detected but apt not found. Only Ubuntu/Debian supported."
+            return 1
+        fi
+    else
+        log_error "Unsupported platform: $OSTYPE"
+        return 1
+    fi
+}
+
+# Check environment exists for Ubuntu (venv)
+check_ubuntu_env() {
+    local venv_path="$REPO_ROOT/$ENV_NAME"
+    if [ ! -d "$venv_path" ]; then
+        log_error "Virtual environment not found at $venv_path"
+        echo ""
+        echo "Please run the setup script first:"
+        echo "  ./scripts/setup_workspace.sh --env-name $ENV_NAME --ros-distro $ROS_DISTRO"
+        return 1
+    fi
+}
+
+# Check environment exists for macOS (conda)
+check_macos_env() {
+    if [[ -n "$CONDA_DEFAULT_ENV" && "$CONDA_DEFAULT_ENV" == "$ENV_NAME" ]]; then
+        log_info "Already in target conda environment '$ENV_NAME'"
+        return 0
+    fi
+
+    if ! command -v mamba &> /dev/null && ! command -v conda &> /dev/null; then
+        log_error "Neither mamba nor conda found!"
+        echo ""
+        echo "Please run the setup script first:"
+        echo "  ./scripts/setup_workspace.sh --env-name $ENV_NAME --ros-distro $ROS_DISTRO"
+        return 1
+    fi
+
+    local manager="mamba"
+    if ! command -v mamba &> /dev/null; then
+        manager="conda"
+    fi
+
+    if ! $manager env list | grep -q "\s$ENV_NAME\s"; then
+        log_error "Conda environment '$ENV_NAME' not found!"
+        echo ""
+        echo "Please run the setup script first:"
+        echo "  ./scripts/setup_workspace.sh --env-name $ENV_NAME --ros-distro $ROS_DISTRO"
+        return 1
+    fi
+}
+
+# Check if already in correct conda environment
+check_conda_env_status() {
+    if [[ -n "$CONDA_DEFAULT_ENV" ]]; then
+        if [[ "$CONDA_DEFAULT_ENV" == "$ENV_NAME" ]]; then
+            log_info "Already in target environment '$ENV_NAME'"
+            return 0
+        else
+            log_warning "Currently in environment '$CONDA_DEFAULT_ENV', will switch to '$ENV_NAME'"
+            return 1
+        fi
+    fi
+    return 1
+}
+
+# Activate Ubuntu environment
+activate_ubuntu() {
+    local venv_path="$REPO_ROOT/$ENV_NAME"
+
+    log_info "[1/3] Activating virtual environment..."
+    source "$venv_path/bin/activate"
+
+    log_info "[2/3] Sourcing ROS2 environment..."
+    if [ -f "/opt/ros/$ROS_DISTRO/setup.bash" ]; then
+        source "/opt/ros/$ROS_DISTRO/setup.bash"
+    else
+        log_error "ROS2 $ROS_DISTRO not found at /opt/ros/$ROS_DISTRO"
+        return 1
+    fi
+
+    log_info "[3/3] Sourcing workspace overlay..."
+    if [ -f "$ROS2_WS_PATH/install/setup.bash" ]; then
+        source "$ROS2_WS_PATH/install/setup.bash"
+    else
+        log_warning "Workspace not built yet. Run: cd $ROS2_WS_PATH && colcon build --symlink-install"
+    fi
+}
+
+# Activate macOS environment
+activate_macos() {
+    local manager="mamba"
+    if ! command -v mamba &> /dev/null; then
+        manager="conda"
+    fi
+
+    if check_conda_env_status; then
+        log_info "[1/2] Already in conda environment '$ENV_NAME', skipping activation..."
+    else
+        log_info "[1/2] Activating conda environment '$ENV_NAME'..."
+        eval "$($manager shell hook)"
+        $manager activate "$ENV_NAME"
+    fi
+
+    if ! command -v ros2 &> /dev/null; then
+        log_error "ROS2 not available in environment. Check RoboStack installation."
+        return 1
+    fi
+
+    log_info "[2/2] Sourcing workspace overlay..."
+    if [ -f "$ROS2_WS_PATH/install/setup.bash" ]; then
+        source "$ROS2_WS_PATH/install/setup.bash"
+    else
+        log_warning "Workspace not built yet. Run: cd $ROS2_WS_PATH && colcon build --symlink-install"
+    fi
+}
+
+# Verify setup
+verify_setup() {
+    log_info "Verifying environment..."
+
+    if ! command -v ros2 &> /dev/null; then
+        log_error "ROS2 command not available"
+        return 1
+    fi
+
+    local python_path=$(which python3)
+    log_info "Python: $python_path"
+
+    # Check for agenticros packages
+    for pkg in agenticros_msgs agenticros_discovery agenticros_agent; do
+        if ros2 pkg list 2>/dev/null | grep -q "$pkg"; then
+            log_success "Package found: $pkg"
+        else
+            log_warning "Package not found: $pkg (workspace may need to be built)"
+        fi
+    done
+
+    return 0
+}
+
+# Main execution
+main() {
+    echo "======================================"
+    echo "AgenticROS Workspace Activation"
+    echo "======================================"
+    echo ""
+
+    if ! detect_platform; then
+        return 1
+    fi
+
+    log_info "Platform detected: $PLATFORM"
+    log_info "Environment name: $ENV_NAME"
+    log_info "ROS2 distribution: $ROS_DISTRO"
+    log_info "Repository root: $REPO_ROOT"
+    echo ""
+
+    case $PLATFORM in
+        ubuntu)
+            if ! check_ubuntu_env; then
+                return 1
+            fi
+            if ! activate_ubuntu; then
+                return 1
+            fi
+            ;;
+        macos)
+            if ! check_macos_env; then
+                return 1
+            fi
+            if ! activate_macos; then
+                return 1
+            fi
+            ;;
+        *)
+            log_error "Unsupported platform: $PLATFORM"
+            return 1
+            ;;
+    esac
+
+    echo ""
+
+    if verify_setup; then
+        log_success "Environment verification passed!"
+    else
+        log_warning "Environment verification had issues, but activation completed"
+    fi
+
+    echo ""
+    log_success "Workspace activation complete!"
+    echo ""
+    echo "Environment Details:"
+    echo "  Platform:     $PLATFORM"
+    echo "  Environment:  $ENV_NAME"
+    echo "  ROS2 Distro:  $ROS_DISTRO"
+    echo "  Python:       $(which python3)"
+    echo "  Workspace:    $ROS2_WS_PATH"
+    echo ""
+    echo "Ready for development! You can now:"
+    echo "  - Build packages:  cd ros2_ws && colcon build --symlink-install"
+    echo "  - Run discovery:   ros2 run agenticros_discovery discovery_node"
+    echo "  - Run agent:       ros2 run agenticros_agent agent_node"
+    echo "  - List topics:     ros2 topic list"
+    echo ""
+}
+
+main

package/runtime/scripts/agenticros-describer.policy.yaml

@@ -0,0 +1,96 @@
+# NemoClaw policy preset that lets the AgenticROS plugin call a vision
+# model on the host for describing camera snapshots. Without this preset
+# the OPA proxy denies the plugin's outbound HTTP request to Ollama with
+# a 403, and ros2_camera_snapshot returns no "Vision description:" line.
+#
+# Apply with::
+#
+#   nemoclaw nemo policy-add --from-file scripts/agenticros-describer.policy.yaml --yes
+#
+# Wire-level note:
+#   The plugin's describer makes an HTTP/1.1 POST to
+#   ``http://host.docker.internal:11434/v1/chat/completions`` (default).
+#   That is a *regular HTTP REST* request — NOT a CONNECT tunnel like the
+#   rosbridge WebSocket. Two consequences:
+#
+#     * We use ``protocol: rest`` with explicit ``rules`` (same shape as
+#       the built-in ``managed_inference`` and ``local_inference`` policies
+#       and our ``openai`` preset). The raw L4 ``access: full`` shape used
+#       for the rosbridge preset does NOT match HTTP method/path REST
+#       traffic — you'll see a 403 "FORWARD denied POST ..." in
+#       /var/log/openshell.*.log if you try it.
+#
+#     * ``host.docker.internal`` resolves to the Docker bridge gateway
+#       (an RFC1918 address, typically 172.19.0.1). The OpenShell SSRF
+#       guard default-denies private destinations, so we still need the
+#       ``allowed_ips`` block listing the three private CIDRs — same as
+#       the rosbridge preset.
+
+preset:
+  name: agenticros-describer
+  description: "AgenticROS plugin -> host Ollama (vision) on :11434 for camera snapshot descriptions"
+
+network_policies:
+  agenticros_describer:
+    name: agenticros_describer
+    endpoints:
+      - host: host.docker.internal
+        port: 11434
+        protocol: rest
+        enforcement: enforce
+        allowed_ips:
+          - 10.0.0.0/8
+          - 172.16.0.0/12
+          - 192.168.0.0/16
+        rules:
+          - allow:
+              method: POST
+              path: /**
+          - allow:
+              method: GET
+              path: /**
+      - host: host.openshell.internal
+        port: 11434
+        protocol: rest
+        enforcement: enforce
+        allowed_ips:
+          - 10.0.0.0/8
+          - 172.16.0.0/12
+          - 192.168.0.0/16
+        rules:
+          - allow:
+              method: POST
+              path: /**
+          - allow:
+              method: GET
+              path: /**
+      # NemoClaw's Ollama auth proxy. Useful if you ever point the
+      # describer URL at the auth-proxied endpoint instead of raw Ollama.
+      - host: host.openshell.internal
+        port: 11435
+        protocol: rest
+        enforcement: enforce
+        allowed_ips:
+          - 10.0.0.0/8
+          - 172.16.0.0/12
+          - 192.168.0.0/16
+        rules:
+          - allow:
+              method: POST
+              path: /**
+          - allow:
+              method: GET
+              path: /**
+    # The OPA proxy denies requests whose calling binary is not in the
+    # allowed list (the OCSF log shows "DENIED -(0) -> ..." when this
+    # check fails — "-(0)" means binary attribution failed). Mirroring the
+    # built-in ``local_inference`` allowlist covers the AgenticROS plugin
+    # (which runs in-process inside the openclaw-gateway node process),
+    # the gateway's own outbound HTTP, and shell-based test calls
+    # (``curl`` from inside the sandbox).
+    binaries:
+      - path: /usr/local/bin/openclaw
+      - path: /usr/local/bin/node
+      - path: /usr/bin/node
+      - path: /usr/bin/curl
+      - path: /usr/bin/python3

package/runtime/scripts/agenticros-proxy.cjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Local proxy so you can open AgenticROS pages in a browser when the gateway
+ * uses token auth. The gateway requires "Authorization: Bearer <token>" and
+ * browsers can't send that for normal URLs; this proxy adds the header.
+ *
+ * Usage:
+ *   node scripts/agenticros-proxy.cjs [port]
+ *   Then open: http://127.0.0.1:<port>/plugins/agenticros/
+ *
+ * Reads gateway URL and token from ~/.openclaw/openclaw.json (gateway.auth.token).
+ */
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const port = parseInt(process.argv[2] || '18790', 10);
+const configPath = process.env.OPENCLAW_CONFIG || path.join(process.env.HOME || '', '.openclaw', 'openclaw.json');
+
+let gatewayOrigin = 'http://127.0.0.1:18789';
+let token = '';
+
+try {
+  const raw = fs.readFileSync(configPath, 'utf8');
+  const config = JSON.parse(raw);
+  const auth = config.gateway?.auth;
+  if (auth?.token) {
+    token = auth.token;
+  }
+  if (config.gateway?.url) {
+    gatewayOrigin = config.gateway.url.replace(/\/$/, '');
+  }
+} catch (e) {
+  console.error('Could not read OpenClaw config:', configPath, e.message);
+  process.exit(1);
+}
+
+if (!token) {
+  console.error('No gateway.auth.token in', configPath);
+  process.exit(1);
+}
+
+const server = http.createServer((req, res) => {
+  if (req.url === '/favicon.ico' || req.url === '/favicon.ico/') {
+    res.writeHead(204, { 'Content-Length': '0' });
+    res.end();
+    return;
+  }
+  const isAgenticros = req.url?.startsWith('/api/agenticros') || req.url?.startsWith('/plugins/agenticros');
+  if (!isAgenticros) {
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not found. Open http://127.0.0.1:' + port + '/plugins/agenticros/');
+    return;
+  }
+
+  const url = new URL(gatewayOrigin);
+  const pathWithQuery = req.url || '/';
+  const headers = { ...req.headers, host: url.host, authorization: 'Bearer ' + token };
+  const qIdx = pathWithQuery.indexOf('?');
+  if (qIdx !== -1) {
+    headers['X-AgenticROS-Query'] = pathWithQuery.slice(qIdx + 1);
+  }
+  const opts = {
+    hostname: url.hostname,
+    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+    path: pathWithQuery,
+    method: req.method,
+    headers,
+  };
+
+  const proxy = http.request(opts, (upstream) => {
+    const code = upstream.statusCode || 200;
+    if (code === 401 || code === 403) {
+      console.warn('Gateway returned ' + code + '. Check gateway.auth.token in', configPath);
+    }
+    res.writeHead(code, upstream.headers);
+    upstream.pipe(res);
+  });
+  proxy.on('error', (e) => {
+    console.error('Proxy error:', e.message);
+    res.writeHead(502, { 'Content-Type': 'text/plain' });
+    res.end('Bad gateway: ' + e.message);
+  });
+  req.pipe(proxy);
+});
+
+server.listen(port, '127.0.0.1', () => {
+  const gwUrl = new URL(gatewayOrigin);
+  const gwPort = gwUrl.port || (gwUrl.protocol === 'https:' ? '443' : '80');
+  console.log('');
+  console.log('  Open this URL in your browser (this proxy adds the auth token):');
+  console.log('  http://127.0.0.1:' + port + '/plugins/agenticros/');
+  console.log('');
+  console.log('  Gateway is at ' + gatewayOrigin + '  (port ' + gwPort + ' from ' + configPath + ')');
+  console.log('  If you see Unauthorized on another port, use the URL above.');
+  console.log('  If you get 503 (camera) or 502 (twist), run the gateway with a single worker (see docs/teleop.md).');
+  console.log('');
+});

package/runtime/scripts/agenticros-rosbridge.policy.yaml

@@ -0,0 +1,62 @@
+# NemoClaw policy preset that allows the AgenticROS plugin (running inside
+# the OpenShell sandbox) to reach a rosbridge_server on the host machine.
+#
+# Apply with::
+#
+#   nemoclaw <sandbox> policy-add --from-file scripts/agenticros-rosbridge.policy.yaml --yes
+#
+# The plugin connects via ws://host.docker.internal:9090 (which resolves to
+# the Docker bridge gateway IP — usually 172.19.0.1). host.openshell.internal
+# is the alias NemoClaw injects with the same IP.
+#
+# Why ``access: full`` / ``tls: skip`` (raw L4 CONNECT tunnel) instead of
+# ``protocol: websocket`` with allow rules:
+#
+#   * The OpenShell proxy MITM that backs ``protocol: websocket`` negotiates
+#     HTTP/2 ALPN by default when it terminates TLS. rosbridge_server is
+#     plain HTTP/1.1 ws://, not wss://, but the proxy still tries to do
+#     HTTP-level routing which breaks the WebSocket upgrade for some clients
+#     (Node ``ws`` library connect attempts disappear without an OPA log
+#     entry).
+#   * Declaring the endpoint as a raw L4 CONNECT tunnel (``access: full``)
+#     tells the proxy to pass the encrypted/cleartext bytes through
+#     unmodified, so the WebSocket upgrade survives intact. The whatsapp
+#     built-in preset uses the same trick for the same underlying reason.
+#   * ``tls: skip`` is needed because the upstream is plain HTTP — there's
+#     no TLS for the proxy to terminate.
+
+preset:
+  name: agenticros-rosbridge
+  description: "AgenticROS plugin -> host rosbridge_server WebSocket on :9090"
+
+network_policies:
+  agenticros_rosbridge:
+    name: agenticros_rosbridge
+    endpoints:
+      - host: host.docker.internal
+        port: 9090
+        access: full
+        tls: skip
+        # Without an explicit allowed_ips block the OPA proxy's SSRF guard
+        # rejects this connection with "resolves to internal address
+        # 172.19.0.1, connection rejected" — because host.docker.internal
+        # is a docker-bridge gateway IP in the RFC1918 range and the guard
+        # default-denies private IPs. Listing the three private CIDRs is
+        # the documented way to tell the guard "yes, I really do want to
+        # talk to a host on a private network here".
+        allowed_ips:
+          - 10.0.0.0/8
+          - 172.16.0.0/12
+          - 192.168.0.0/16
+      - host: host.openshell.internal
+        port: 9090
+        access: full
+        tls: skip
+        allowed_ips:
+          - 10.0.0.0/8
+          - 172.16.0.0/12
+          - 192.168.0.0/16
+    binaries:
+      - { path: /usr/local/bin/openclaw }
+      - { path: /usr/local/bin/node }
+      - { path: /usr/bin/node }

package/runtime/scripts/check-cli-tarball-size.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Tarball-size gate for the `agenticros` npm package.
+ *
+ * Runs `npm pack --dry-run --json` inside packages/agenticros-cli/, parses the
+ * JSON metadata, prints a human summary, and exits non-zero if the unpacked
+ * tarball would exceed MAX_UNPACKED_MB. Used as part of the prepublishOnly
+ * pipeline so accidental fat dependencies don't slip into a release.
+ */
+
+import { execSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MAX_UNPACKED_MB = 20;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI_PKG_DIR = resolve(__dirname, "..", "packages", "agenticros-cli");
+
+const out = execSync("npm pack --dry-run --json", {
+  cwd: CLI_PKG_DIR,
+  encoding: "utf8",
+});
+
+const arr = JSON.parse(out);
+const meta = arr[0];
+const unpackedMb = (meta.unpackedSize / 1_048_576).toFixed(2);
+const packagedMb = (meta.size / 1_048_576).toFixed(2);
+
+process.stdout.write(
+  `[size-check] ${meta.filename}  tarball ${packagedMb} MB  unpacked ${unpackedMb} MB  files ${meta.entryCount}\n`,
+);
+
+if (meta.unpackedSize > MAX_UNPACKED_MB * 1_048_576) {
+  process.stderr.write(
+    `[size-check] FAIL: unpacked size exceeds ${MAX_UNPACKED_MB} MB limit.\n` +
+      "[size-check] Inspect runtime/ - is something too big bundled in by mistake?\n",
+  );
+  process.exit(1);
+}
+process.stdout.write(`[size-check] OK\n`);