Pilot Chunk Transfer

Large file transfer with automatic chunking, resume capability, and integrity verification. Use this skill when: 1. You need to transfer files larger than 10...

Security Scan

The skill's behavior matches its stated purpose (chunked file transfer over the Pilot protocol) but the SKILL.md lists additional runtime dependencies and contains incomplete/underspecified steps you should review before using it in production.

Purpose & Capability

Name and description match the instructions: the SKILL.md shows how to chunk a local file, send per-chunk metadata and files via pilotctl, resume, and reassemble on receipt. Requesting pilotctl is appropriate for a Pilot-protocol transfer skill.

Instruction Scope

Instructions stay within the transfer use case (reading local file, creating temporary chunk files, using pilotctl inbox/send-file). However several operational pieces are underspecified: the receive path does not show how incoming file payloads are stored into $RECV_DIR (it assumes pilotctl will expose them in a particular form), the chunk hash verification step is mentioned but not implemented, and the resume/state handling is only sketched. The scripts also write temporary files to /tmp and to $HOME/.pilot which is expected but worth noting.

Install Mechanism

Instruction-only skill with no install spec and no fetched archives — low installation risk. The skill expects existing binaries rather than installing code itself.

Credentials

Registry metadata declares only pilotctl as a required binary and no env vars; the SKILL.md additionally requires jq, dd, md5sum, and bc. This mismatch is a configuration oversight (the extra binaries are reasonable for the stated task) but they should be declared. No credentials or unrelated environment variables are requested.

Persistence & Privilege

Skill is not always-on and can be invoked by the user (default autonomous invocation allowed). It creates local directories under $HOME/.pilot and temporary files under /tmp, which is proportionate for a file-transfer tool and does not modify other skills or system-wide settings.

Assessment

This skill appears to do what it says (chunked file transfers over the Pilot protocol), but check a few things before you install/use it: 1) Confirm pilotctl and the Pilot daemon are trusted and expected on your system. 2) Ensure the additional runtime tools the SKILL.md uses (jq, dd, md5sum, bc) are available — the registry metadata should list them but does not. 3) Review/complete the receive path: the SKILL.md mentions verifying per-chunk hashes but doesn't show where received chunk files are written or how verification is enforced; add explicit verification before reassembly. 4) Test with non-sensitive/sample files to validate resume and integrity behavior. 5) Be aware the scripts create temp files in /tmp and store received chunks under $HOME/.pilot — if that location is sensitive, change it. If you need higher assurance, request the publisher to update the skill metadata to declare all required binaries and to provide a complete, robust receive/verification implementation.

Large file transfer with automatic chunking, resume capability, and per-chunk integrity verification. Breaks large files into manageable chunks, tracks transfer progress, and enables resuming interrupted transfers.

Commands

Send file with chunking

FILE="/path/to/large-file.iso"
DEST="1:0001.AAAA.BBBB"
CHUNK_SIZE=$((1024 * 1024))  # 1MB

FILENAME=$(basename "$FILE")
FILESIZE=$(stat -f %z "$FILE" 2>/dev/null || stat -c %s "$FILE")
TOTAL_CHUNKS=$(( (FILESIZE + CHUNK_SIZE - 1) / CHUNK_SIZE ))

# Send metadata
pilotctl --json send-message "$DEST" \
  --data "{\"type\":\"chunk_transfer_start\",\"filename\":\"$FILENAME\",\"size\":$FILESIZE,\"total_chunks\":$TOTAL_CHUNKS}"

# Send chunks
for ((i=0; i<TOTAL_CHUNKS; i++)); do
  dd if="$FILE" bs="$CHUNK_SIZE" skip="$i" count=1 2>/dev/null > "/tmp/chunk_$i.dat"
  CHUNK_HASH=$(md5sum "/tmp/chunk_$i.dat" | cut -d' ' -f1)

  pilotctl --json send-message "$DEST" \
    --data "{\"type\":\"chunk_metadata\",\"chunk_id\":$i,\"hash\":\"$CHUNK_HASH\"}"

  pilotctl --json send-file "$DEST" "/tmp/chunk_$i.dat"
  rm "/tmp/chunk_$i.dat"
done

# Send completion
pilotctl --json send-message "$DEST" \
  --data "{\"type\":\"chunk_transfer_complete\",\"filename\":\"$FILENAME\"}"

Receive and reassemble chunks

RECV_DIR="$HOME/.pilot/chunk-recv"
mkdir -p "$RECV_DIR"

INBOX=$(pilotctl --json inbox)
echo "$INBOX" | jq -c '.messages[]' | while read -r msg; do
  TYPE=$(echo "$msg" | jq -r '.type')

  case "$TYPE" in
    chunk_transfer_start)
      FILENAME=$(echo "$msg" | jq -r '.filename')
      mkdir -p "$RECV_DIR/$FILENAME.chunks"
      ;;

    chunk_metadata)
      CHUNK_ID=$(echo "$msg" | jq -r '.chunk_id')
      EXPECTED_HASH=$(echo "$msg" | jq -r '.hash')
      # Verify chunk hash after receiving file
      ;;

    chunk_transfer_complete)
      FILENAME=$(echo "$msg" | jq -r '.filename')
      cat "$RECV_DIR/$FILENAME.chunks"/chunk_* > "$RECV_DIR/$FILENAME"
      rm -rf "$RECV_DIR/$FILENAME.chunks"
      echo "Reassembled: $RECV_DIR/$FILENAME"
      ;;
  esac
done

Resume interrupted transfer

STATE_FILE="/tmp/transfer_state.json"

if [ -f "$STATE_FILE" ]; then
  START_CHUNK=$(jq -r ".\"$FILENAME\".last_chunk // 0" "$STATE_FILE")
else
  START_CHUNK=0
fi

# Continue from START_CHUNK and update state after each chunk

Workflow Example

# Send large file in chunks with resume capability
./pilot-chunk-transfer.sh send /path/to/large.iso 1:0001.AAAA.BBBB

# Receive in background
./pilot-chunk-transfer.sh receive

Dependencies

Requires pilot-protocol skill with running daemon, jq for JSON parsing, dd for chunk extraction, md5sum for integrity verification, and bc for progress calculations.