Add skills subcommand and plugin validation CI

Embed the 13 claude-plugin files in the binary at compile time via
include_str!(), exposing them through `no skills install` (writes to
~/.claude/plugins/no/) and `no skills export <path>`.

Add validate-plugin job to CI workflow.

Author: felipefdl

.github/workflows/ci.yml

@@ -86,6 +86,17 @@ jobs:
       - name: Run tests
         run: just test
 
+  plugin-validate:
+    name: Validate Plugin
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: taiki-e/install-action@just
+
+      - name: Validate plugin structure
+        run: just validate-plugin
+
   build-cross:
     name: Build (${{ matrix.name }})
     needs: lint

Cargo.lock

@@ -40,6 +40,7 @@ surge-ping = "0.8"
 [dev-dependencies]
 axum = { version = "0.8", features = ["ws"] }
 rumqttd = "0.20"
+tempfile = "3"
 
 [profile.release]
 lto = true

Cargo.toml

@@ -29,3 +29,52 @@ test-integration:
 
 run *args:
   cargo run -- {{args}}
+
+validate-plugin:
+  #!/usr/bin/env bash
+  set -euo pipefail
+  echo "Validating plugin structure..."
+  # Check plugin.json exists and is valid JSON
+  if ! python3 -m json.tool claude-plugin/.claude-plugin/plugin.json > /dev/null 2>&1; then
+    echo "FAIL: claude-plugin/.claude-plugin/plugin.json is missing or invalid JSON"
+    exit 1
+  fi
+  echo "  plugin.json: OK"
+  # Check all SKILL.md files exist and have YAML frontmatter
+  skills=(
+    "http-requests"
+    "websocket-debugging"
+    "network-diagnostics"
+    "mqtt-messaging"
+    "tcp-udp-testing"
+    "sse-monitoring"
+    "output-filtering"
+  )
+  for skill in "${skills[@]}"; do
+    skill_file="claude-plugin/skills/${skill}/SKILL.md"
+    if [ ! -f "${skill_file}" ]; then
+      echo "FAIL: ${skill_file} not found"
+      exit 1
+    fi
+    # Check YAML frontmatter (starts with ---)
+    if ! head -1 "${skill_file}" | grep -q "^---$"; then
+      echo "FAIL: ${skill_file} missing YAML frontmatter"
+      exit 1
+    fi
+    # Check name in frontmatter matches directory name
+    frontmatter_name=$(grep "^name:" "${skill_file}" | head -1 | sed 's/^name: *//')
+    if [ "${frontmatter_name}" != "${skill}" ]; then
+      echo "FAIL: ${skill_file} frontmatter name '${frontmatter_name}' does not match directory '${skill}'"
+      exit 1
+    fi
+    echo "  ${skill}/SKILL.md: OK"
+  done
+  # Check reference files exist
+  for ref in cli-reference.md output-schema.md error-codes.md; do
+    if [ ! -f "claude-plugin/references/${ref}" ]; then
+      echo "FAIL: claude-plugin/references/${ref} not found"
+      exit 1
+    fi
+    echo "  references/${ref}: OK"
+  done
+  echo "Plugin validation passed."

justfile

@@ -117,6 +117,39 @@ pub enum Command {
   /// Filter JSON from stdin with a jq expression.
   #[command(about = "Filter JSON from stdin with a jq expression")]
   Jq(JqArgs),
+
+  /// Manage AI agent skills.
+  #[command(about = "Manage AI agent skills")]
+  Skills {
+    #[command(subcommand)]
+    action: SkillsAction,
+  },
+}
+
+// -- Skills --
+
+/// Skills subcommand: install or export AI agent skills.
+#[derive(Subcommand)]
+pub enum SkillsAction {
+  #[command(about = "Install skills to ~/.claude/plugins/no")]
+  Install(SkillsInstallArgs),
+
+  #[command(about = "Export skills to a directory")]
+  Export(SkillsExportArgs),
+}
+
+/// Arguments for skills install.
+#[derive(clap::Args)]
+pub struct SkillsInstallArgs {
+  #[arg(long, value_name = "DIR", help = "Custom install directory")]
+  pub path: Option<String>,
+}
+
+/// Arguments for skills export.
+#[derive(clap::Args)]
+pub struct SkillsExportArgs {
+  #[arg(help = "Target directory")]
+  pub path: String,
 }
 
 // -- Jq --
@@ -714,6 +747,42 @@ mod tests {
     assert_eq!(args.query, "8.8.8.8");
   }
 
+  #[test]
+  fn skills_install() {
+    let cli = Cli::try_parse_from(["no", "skills", "install"]).unwrap();
+    let Command::Skills { action } = cli.command else {
+      panic!("expected Skills command")
+    };
+    let SkillsAction::Install(args) = action else {
+      panic!("expected Install action")
+    };
+    assert!(args.path.is_none());
+  }
+
+  #[test]
+  fn skills_install_with_path() {
+    let cli = Cli::try_parse_from(["no", "skills", "install", "--path", "/tmp/custom"]).unwrap();
+    let Command::Skills { action } = cli.command else {
+      panic!("expected Skills command")
+    };
+    let SkillsAction::Install(args) = action else {
+      panic!("expected Install action")
+    };
+    assert_eq!(args.path.as_deref(), Some("/tmp/custom"));
+  }
+
+  #[test]
+  fn skills_export() {
+    let cli = Cli::try_parse_from(["no", "skills", "export", "/tmp/out"]).unwrap();
+    let Command::Skills { action } = cli.command else {
+      panic!("expected Skills command")
+    };
+    let SkillsAction::Export(args) = action else {
+      panic!("expected Export action")
+    };
+    assert_eq!(args.path, "/tmp/out");
+  }
+
   #[test]
   fn missing_required_args_fails() {
     let result = Cli::try_parse_from(["no", "http"]);

src/cli.rs

@@ -50,6 +50,7 @@ async fn main() {
     Command::Ping(args) => protocols::ping::run(args, mode, no_color, timeout, count, verbose).await,
     Command::Whois(args) => protocols::whois::run(args, mode, no_color, timeout, verbose).await,
     Command::Jq(args) => protocols::jq::run(args).await,
+    Command::Skills { action } => protocols::skills::run(action).await,
   };
 
   if let Err(e) = result {

src/main.rs

@@ -11,6 +11,7 @@ pub mod http;
 pub mod jq;
 pub mod mqtt;
 pub mod ping;
+pub mod skills;
 pub mod sse;
 pub mod tcp;
 pub mod udp;

src/protocols/mod.rs

@@ -0,0 +1,150 @@
+use crate::cli::SkillsAction;
+use crate::error::{ErrorCode, NetError};
+use crate::output::Protocol;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const PLUGIN_FILES: &[(&str, &str)] = &[
+  (
+    ".claude-plugin/plugin.json",
+    include_str!("../../claude-plugin/.claude-plugin/plugin.json"),
+  ),
+  ("README.md", include_str!("../../claude-plugin/README.md")),
+  ("LICENSE", include_str!("../../claude-plugin/LICENSE")),
+  (
+    "skills/http-requests/SKILL.md",
+    include_str!("../../claude-plugin/skills/http-requests/SKILL.md"),
+  ),
+  (
+    "skills/websocket-debugging/SKILL.md",
+    include_str!("../../claude-plugin/skills/websocket-debugging/SKILL.md"),
+  ),
+  (
+    "skills/network-diagnostics/SKILL.md",
+    include_str!("../../claude-plugin/skills/network-diagnostics/SKILL.md"),
+  ),
+  (
+    "skills/mqtt-messaging/SKILL.md",
+    include_str!("../../claude-plugin/skills/mqtt-messaging/SKILL.md"),
+  ),
+  (
+    "skills/tcp-udp-testing/SKILL.md",
+    include_str!("../../claude-plugin/skills/tcp-udp-testing/SKILL.md"),
+  ),
+  (
+    "skills/sse-monitoring/SKILL.md",
+    include_str!("../../claude-plugin/skills/sse-monitoring/SKILL.md"),
+  ),
+  (
+    "skills/output-filtering/SKILL.md",
+    include_str!("../../claude-plugin/skills/output-filtering/SKILL.md"),
+  ),
+  (
+    "references/cli-reference.md",
+    include_str!("../../claude-plugin/references/cli-reference.md"),
+  ),
+  (
+    "references/output-schema.md",
+    include_str!("../../claude-plugin/references/output-schema.md"),
+  ),
+  (
+    "references/error-codes.md",
+    include_str!("../../claude-plugin/references/error-codes.md"),
+  ),
+];
+
+fn home_dir() -> Result<PathBuf, NetError> {
+  std::env::var("HOME")
+    .or_else(|_| std::env::var("USERPROFILE"))
+    .map(PathBuf::from)
+    .map_err(|_| NetError::new(ErrorCode::IoError, "could not determine home directory", Protocol::Http))
+}
+
+fn write_plugin(target: &Path) -> Result<(), NetError> {
+  for (rel_path, content) in PLUGIN_FILES {
+    let dest = target.join(rel_path);
+    if let Some(parent) = dest.parent() {
+      fs::create_dir_all(parent).map_err(|e| {
+        NetError::new(
+          ErrorCode::IoError,
+          format!("failed to create directory {}: {e}", parent.display()),
+          Protocol::Http,
+        )
+      })?;
+    }
+    fs::write(&dest, content).map_err(|e| {
+      NetError::new(
+        ErrorCode::IoError,
+        format!("failed to write {}: {e}", dest.display()),
+        Protocol::Http,
+      )
+    })?;
+  }
+  Ok(())
+}
+
+pub async fn run(action: SkillsAction) -> Result<(), NetError> {
+  match action {
+    SkillsAction::Install(args) => {
+      let target = match args.path {
+        Some(p) => PathBuf::from(p),
+        None => home_dir()?.join(".claude/plugins/no"),
+      };
+      write_plugin(&target)?;
+      println!("Skills installed to {}", target.display());
+    }
+    SkillsAction::Export(args) => {
+      let target = PathBuf::from(&args.path);
+      write_plugin(&target)?;
+      println!("Skills exported to {}", target.display());
+    }
+  }
+  Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn plugin_files_not_empty() {
+    for (path, content) in PLUGIN_FILES {
+      assert!(!content.is_empty(), "embedded file {path} should not be empty");
+    }
+  }
+
+  #[test]
+  fn plugin_files_count() {
+    assert_eq!(PLUGIN_FILES.len(), 13);
+  }
+
+  #[tokio::test]
+  async fn install_to_temp_dir() {
+    let dir = tempfile::tempdir().unwrap();
+    let target = dir.path().to_path_buf();
+    let action = SkillsAction::Install(crate::cli::SkillsInstallArgs {
+      path: Some(target.to_string_lossy().into_owned()),
+    });
+    run(action).await.unwrap();
+
+    assert!(target.join(".claude-plugin/plugin.json").exists());
+    assert!(target.join("skills/http-requests/SKILL.md").exists());
+    assert!(target.join("references/cli-reference.md").exists());
+    assert!(target.join("README.md").exists());
+    assert!(target.join("LICENSE").exists());
+  }
+
+  #[tokio::test]
+  async fn export_to_temp_dir() {
+    let dir = tempfile::tempdir().unwrap();
+    let target = dir.path().join("exported");
+    let action = SkillsAction::Export(crate::cli::SkillsExportArgs {
+      path: target.to_string_lossy().into_owned(),
+    });
+    run(action).await.unwrap();
+
+    assert!(target.join(".claude-plugin/plugin.json").exists());
+    assert!(target.join("skills/mqtt-messaging/SKILL.md").exists());
+    assert!(target.join("references/error-codes.md").exists());
+  }
+}