Pilot Github Bridge

Bridge GitHub webhook events as Pilot Protocol events. Use this skill when: 1. You need to receive GitHub events in Pilot agents 2. You want to trigger agent...

Security Scan

The skill's high-level purpose (bridging GitHub webhooks into Pilot) matches the instructions, but there are inconsistencies and missing security-critical details (undeclared tools, absent webhook-secret handling, and example advice that exposes a public daemon) that make the package suspicious until clarified.

Purpose & Capability

The declared required binary (pilotctl) and the instructions (pilotctl commands) align with the stated purpose. However, SKILL.md and the Dependencies section also reference gh CLI, python3, jq, and an HTTP relay server even though the registry metadata only lists pilotctl. gh is unnecessary for webhook reception (and the file even says to use gh when you need direct API access), so its presence in Dependencies is inconsistent. The instructions also implicitly require jq, sed, and python3 but these are not declared as required binaries.

Instruction Scope

The runtime instructions direct the agent to start a public daemon (--public) and run an external HTTP relay server. The example loop accepts events and acts on them but gives no guidance to validate GitHub webhook signatures, check origins, or authenticate the relay — making the workflow vulnerable to forged or replayed events. The instructions also recommend running a publicly reachable daemon, which increases exposure if not properly firewalled or access-controlled.

Install Mechanism

This is an instruction-only skill with no install spec and no code files, so nothing is written to disk by an installer. That is the lowest-risk install model.

Credentials

No environment variables or secrets are declared, but a GitHub webhook integration typically requires a webhook secret (or other credentials) to validate payloads; that secret is not requested or mentioned. The skill also references Pilot daemon/public hosting but does not declare any Pilot-specific credentials. The mismatch between declared requirements (none) and implied needs (webhook secret, python3/jq tooling, potential Pilot auth) is concerning.

Persistence & Privilege

The skill is not marked always:true and does not request persistent system-wide privileges or modify other skills. Autonomous invocation is allowed (platform default) but not combined here with other high privileges.

Scan Findings in Context

[no-findings] expected: The static scanner found no code or regex matches because this is an instruction-only skill (only SKILL.md present). That absence does not imply the skill is safe; the security-relevant issues are in the prose/instructions.

What to consider before installing

Before installing or running this skill: (1) Ask the author to clarify and correct the declared requirements — explicitly list pilotctl, python3, jq, sed if the examples require them, and remove gh from Dependencies unless it is actually used. (2) Require explicit handling of GitHub webhook secrets: the workflow must validate X-Hub-Signature / X-Hub-Signature-256 (or equivalent) before acting on events; do not accept unsigned webhooks. (3) Avoid running the daemon with --public unless you understand and control network exposure; prefer binding to localhost or using a secured relay and firewall rules. (4) Run the relay and processing loop on an isolated host/container with least privilege, enable logging/auditing, and add rate-limiting and input validation to avoid command injection or forged events. (5) If you need guarantees, request a revised SKILL.md that lists exact required binaries, any needed environment variables (e.g., WEBHOOK_SECRET, PILOT_AUTH token), and explicit security steps (signature verification and auth). If the author cannot clarify these inconsistencies, treat the skill as risky and avoid deploying it in production.

Bridge GitHub webhook events into Pilot Protocol, enabling agents to react to repository events.

Commands

Configure Webhook Receiver

pilotctl --json set-webhook https://your-relay.example.com/github
pilotctl --json listen 1005

Subscribe to Events

pilotctl --json subscribe github-relay github-events

Check Received Events

pilotctl --json inbox
pilotctl --json recv 1005

Workflow Example

#!/bin/bash
# GitHub webhook relay

pilotctl --json daemon start --hostname github-relay --public
pilotctl --json listen 1005 &

# Start HTTP relay (external Python server)
python3 github_relay_server.py &

# Process events
pilotctl --json subscribe localhost github-events

while true; do
  EVENT=$(pilotctl --json recv 1005 --timeout 120s)
  REPO=$(echo "$EVENT" | jq -r '.repository.full_name')
  EVENT_TYPE=$(echo "$EVENT" | jq -r '.event')

  case "$EVENT_TYPE" in
    push)
      BRANCH=$(echo "$EVENT" | jq -r '.ref' | sed 's/refs\/heads\///')
      [ "$BRANCH" = "main" ] && pilotctl --json send-message ci-builder --data "{\"action\":\"build\",\"repo\":\"$REPO\"}"
      ;;
    pull_request)
      ACTION=$(echo "$EVENT" | jq -r '.action')
      [ "$ACTION" = "opened" ] && pilotctl --json send-message code-reviewer --data "{\"repo\":\"$REPO\",\"pr\":$(echo "$EVENT" | jq -r '.number')}"
      ;;
  esac
done

Dependencies

Requires pilot-protocol skill, running daemon, gh CLI, GitHub webhook, and HTTP relay server.