Pilot Stream Data

Real-time NDJSON data streaming over persistent Pilot Protocol connections. Use this skill when: 1. You need to stream structured data in real-time between a...

Security Scan

The skill is an instruction-only helper for sending/receiving NDJSON over the Pilot Protocol using the pilotctl CLI; its requirements and instructions match that purpose and do not request unrelated credentials or risky installs.

Purpose & Capability

Name, description, and required binaries (pilotctl) align with the provided bash examples and stated purpose (real-time NDJSON streaming). Declared ancillary dependencies (jq, bc, optional gzip) are appropriate for the sample commands.

Instruction Scope

SKILL.md only instructs running pilotctl and local unix utilities (jq, bc, gzip) and shows producer/consumer loops; it does not read unrelated system files, ask for credentials, or transmit data to unintended external endpoints. Operational cautions: examples use infinite loops (while true) and write to /tmp/pilot-stream.log; users should monitor resource usage and confirm destination addresses are correct.

Install Mechanism

This is instruction-only with no install spec or downloadable artifacts — minimal risk because nothing is written to disk by the skill itself. It expects the pilotctl binary to already exist on PATH.

Credentials

The skill declares no required environment variables or credentials. The commands in SKILL.md likewise do not access any sensitive environment variables or unrelated configuration paths. This is proportionate for a CLI-based streaming helper.

Persistence & Privilege

The skill does not request always:true or elevated persistence. It is user-invocable and allows autonomous invocation by default (platform normal), but the skill itself does not attempt to modify other skills or system-wide settings.

Assessment

This skill is coherent and low-risk as provided, but before installing consider: (1) Ensure pilotctl and the pilot-protocol implementation you use are from a trusted source and kept up-to-date; the skill assumes a running daemon and network connectivity. (2) Confirm destination addresses (DEST) and any metadata you send do not contain secrets or PII — streaming is continuous and may leak data if misconfigured. (3) The examples use shell pipelines and infinite loops; run them under supervision (or as managed services) to avoid runaway CPU/disk usage. (4) If you rely on encryption/authentication for Pilot Protocol connections, verify those are configured on the daemon; the SKILL.md does not describe secure transport details. (5) When adapting the examples, prefer safe shell practices (quote variables consistently) to avoid accidental word-splitting or unexpected globbing.

Real-time structured data streaming using NDJSON format over Pilot Protocol's persistent connections with backpressure handling.

Commands

Start stream server:

pilotctl --json listen 1002 > /tmp/pilot-stream.log &

Stream NDJSON data:

DEST="1:0001.AAAA.BBBB"
while true; do
  MSG="{\"timestamp\":$(date +%s),\"temp\":$(echo "scale=2; 20 + $RANDOM % 10" | bc),\"humidity\":50}"
  pilotctl --json send "$DEST" 1002 --data "$MSG"
  sleep 1
done

Receive and process stream:

pilotctl --json listen 1002 | while read -r line; do
  TIMESTAMP=$(echo "$line" | jq -r '.timestamp')
  VALUE=$(echo "$line" | jq -r '.value')
  echo "[$TIMESTAMP] Value: $VALUE"
done

Subscribe to stream topic:

pilotctl --json subscribe "$DEST" data-stream | while read -r line; do
  echo "Data: $(echo $line | jq -r '.value')"
done

Workflow Example

#!/bin/bash
# Real-time sensor data streaming

STREAM_PORT=1002
DEST="1:0001.AAAA.BBBB"

# Producer: stream sensor data
produce_stream() {
  echo "Starting stream producer"

  # Send metadata header
  pilotctl --json send "$DEST" "$STREAM_PORT" \
    --data "{\"type\":\"stream_start\",\"schema\":\"temp_humidity_v1\"}"

  # Stream data
  counter=0
  while true; do
    timestamp=$(date +%s)
    temp=$(echo "scale=2; 20 + ($counter % 10)" | bc)
    humidity=$(echo "scale=2; 50 + ($counter % 20)" | bc)

    pilotctl --json send "$DEST" "$STREAM_PORT" \
      --data "{\"type\":\"data\",\"timestamp\":$timestamp,\"temp\":$temp,\"humidity\":$humidity,\"seq\":$counter}"

    counter=$((counter + 1))
    sleep 1
  done
}

# Consumer: receive and process
consume_stream() {
  pilotctl --json listen "$STREAM_PORT" | while read -r line; do
    type=$(echo "$line" | jq -r '.type')

    if [ "$type" = "data" ]; then
      temp=$(echo "$line" | jq -r '.temp')
      echo "Temperature: ${temp}°C"
    fi
  done
}

produce_stream

Dependencies

Requires pilot-protocol skill, running daemon, jq, bc, and optional gzip for compression.