SkillAgentSearch skills...

nks-usbshare

Share USB devices between computers over a TLS link on a LAN, VPN or the internet, with apps for Windows, Linux and macOS, a CLI and an MCP server. C#/.NET 9, no NuGet packages.

Install / Use

claude mcp add nks-hub -- npx -y github:nks-hub/nks-usbshare

If the server publishes to npm under a different name, use that package instead — check the repo README.

About this skill
🔌

MCP Server

Model Context Protocol server

Quality Score

83/100

Supported Platforms

Claude Code
Claude Desktop

Tags

Our assessment of nks-usbshare

nks-usbshare scores 83/100 on our quality scale, 2989th of 4,705 Development & Engineering skills we index.

Its MCP Server is 21 KB long, well organised into 20 sections with 8 code examples: a thorough specification that gives an agent plenty to work with.

It has 3 GitHub stars, so there is little community track record yet; judge it on its content.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
3/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 37 days ago, so nks-usbshare is actively maintained.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 80/100, with 2 cautions from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-16. Automated pattern scan on 2026-11-16. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

nks-usbshare compared with similar skills

All 4 of these similar skills score higher than nks-usbshare; compare them before choosing.

SkillScoreStarsUpdatedFormat
nks-usbshare (this skill)by nks-hub83337d agoMCP Server
taste-skillby Leonxlnx100117.0k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.4k9d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.9ktodayCLAUDE.md

Frequently asked questions

How do I install nks-usbshare?
Run claude mcp add nks-hub -- npx -y github:nks-hub/nks-usbshare. The install tabs above show the steps for each supported agent.
Which AI agents does nks-usbshare work with?
It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
Is nks-usbshare safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 80/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is nks-usbshare still maintained?
The repository was last updated 37 days ago, so nks-usbshare is actively maintained.

NKS UsbShare

CI GitHub Release .NET Platforms NuGet packages License

Share USB devices between computers over an encrypted TCP link on a LAN, across a VPN or over the internet. A flash drive, a phone, a dongle: plug it into one machine, use it from another as though it were plugged in there.

Written in C# on .NET 9 with no NuGet packages, on top of WinUSB and SetupAPI on Windows, usbfs on Linux, IOKit on macOS and the .NET TLS stack.

One thing cannot be written in user mode: the virtual USB controller that makes a remote device visible to every application on Windows. That is a kernel driver, and it has to be signed by someone Windows already trusts. The application fetches and installs it on its own the first time it is needed; see Dependencies.

The computer a device is plugged into: everything attached, and what is shared:

Windows

The computer using it: a phone attached across the network, listed as a local device:

A remote device in use

| Settings | Linux | |---|---| | Settings | Linux |

Every window shows the same thing in the same shape: identity and pairing details pinned at the top, then a table of devices with a button per row, then the computers allowed in.

Features

  • 🔌 USB over the network - Plug a device into one computer and use it from another, on a LAN, across a VPN or over the internet
  • 🔒 Encrypted and pinned - TLS 1.3 (1.2 floor), self-signed P-384 identities pinned on first use, 125-bit pairing tokens, optional mutual TLS
  • 🛂 Per-device access control - Allow lists of client fingerprints per device, named clients and instant blocking
  • 🖥️ Native apps on three platforms - WPF on Windows, GTK 3 on Linux, AppKit on macOS, plus the cross-platform nksusb CLI
  • 🤖 MCP server - Manage sharing, pairing and imports from AI agents over the Model Context Protocol
  • 🧲 Driver claim on Windows - Moves a device from its class driver onto winusb.sys and gives it back, with Secure Boot left on
  • 🧩 Whole-OS attach - Presents a remote device to the local USB stack through vhci_hcd on Linux or the usbip-win2 controller on Windows, installed automatically
  • 💾 Driverless storage access - Reads a remote disk directly over SCSI Bulk-Only Transport with a built-in FAT32 reader
  • 📦 Zero NuGet packages - Protocol, MCP JSON-RPC, descriptor parser, SCSI/FAT32 readers, UI bindings and test runner are all in-repo

Requirements

  • Windows x64, Linux x64 or macOS arm64 (release builds are self-contained)
  • .NET 9 SDK to build from source
  • Windows: administrator consent once to claim a device or install the virtual USB controller
  • Linux: the in-kernel vhci_hcd controller for whole-OS attach; GTK 3 and a display for the desktop app
  • macOS: whole-OS attach is not possible today; remote devices are reachable through RemoteUsbDevice and nksusb storage

Installation

Download a self-contained build for your platform from GitHub Releases:

| Package | Platforms | |---------|-----------| | NksUsbShare.Desktop | win-x64 | | NksUsbShare.Gtk | linux-x64 | | NksUsbShare.Mac | osx-arm64 | | NksUsbShare.Cli | win-x64, linux-x64, osx-arm64 | | NksUsbShare.Mcp | win-x64, linux-x64, osx-arm64 |

Or build the desktop application from source:

Windows: dotnet build src/NksUsbShare.Desktop, then run NksUsbShare.exe.

macOS: dotnet publish src/NksUsbShare.Mac -r osx-arm64 --self-contained. Put the binary in a .app bundle so LaunchServices treats it as a normal application.

Linux: dotnet publish src/NksUsbShare.Gtk -r linux-x64 --self-contained, then run nksusb-gtk. On a machine with no display it prints that and exits.

Usage

Desktop application

The Windows, macOS and Linux applications all accept --home <dir> like the terminal application, so a second node can be run beside the real one without disturbing its settings.

Command line (all platforms)

dotnet build src/NksUsbShare.Cli

nksusb list                          # local devices and what is shared
nksusb share 3                       # share the third device, claiming it from Windows if needed
nksusb giveback                      # return every claimed device to its original driver
nksusb serve                         # run the node until interrupted

nksusb pair 192.0.2.10 ABCDE-FGHIJ-KLMNO-PQRST-UVWXY
nksusb remote 192.0.2.10             # what that host offers
nksusb import 192.0.2.10 <device-id> # hold a device until interrupted
nksusb attach 192.0.2.10 <device-id> # hand it to this machine's USB stack
nksusb storage 192.0.2.10 <device-id># read a remote disk directly, without a driver

nksusb clients                       # computers that have connected here
nksusb access 3 anyone               # offer the third device to any paired computer
nksusb access 3 laptop workshop      # or only to those two
nksusb block laptop                  # refuse a computer even with the right token

A computer can be named by its name or by any unambiguous part of its key fingerprint. These commands write the settings file, so a node that is already running picks them up when it restarts; the windowed applications change their own running node straight away.

Settings live in %APPDATA%\nks-usbshare or ~/.config/nks-usbshare, overridable with NKS_USBSHARE_HOME or --home.

MCP server

{
  "mcpServers": {
    "nks-usbshare": {
      "type": "stdio",
      "command": "<path-to>/nksusb-mcp"
    }
  }
}

| Tool | Description | |------|-------------| | node_info | Identity, platform, pairing token and listening address | | list_local_devices | Local USB devices and whether each one is shared | | share_device / unshare_device | Offer a device, optionally claiming it first | | release_claimed_devices | Give every claimed device back to its original driver | | list_clients | Computers that have connected to this node | | set_client_blocked | Refuse or re-admit a computer | | set_device_access | Choose which computers may use a shared device | | list_hosts / pair_host / forget_host | Manage paired computers | | list_remote_devices | What another computer offers | | import_device / release_device / list_imports | Hold and release remote devices | | recent_activity | The node's activity log |

What works today

| | Windows | Linux | macOS | |---|---|---|---| | Enumerate local USB devices | verified | verified | verified | | Share a device (export) | verified | verified | implemented | | Claim a device from its class driver | verified | n/a | n/a | | Use a remote device from an application | verified | verified | verified | | Present a remote device to the whole OS | verified | verified | not possible today | | Native application window | WPF, verified | GTK, verified | AppKit, verified | | Command line | verified | verified | verified | | Per-device access lists and blocking | verified | verified | implemented |

"Verified" means it was exercised against real hardware; "implemented" means the code is complete but has not yet been run on that platform.

The Windows export path was checked end to end: a USB flash drive plugged into one machine was claimed from its class driver, shared, and then read from a Windows 11 virtual machine on another host across a VPN. The virtual machine pulled the device and configuration descriptors straight off the hardware (mass storage, class 08/06/50, two 512 byte bulk endpoints), so real transfers crossed the encrypted link, not cached metadata.

nksusb probe 192.0.2.10 'USB\VID_FFFF&PID_5678\0123456789ABC'

  Disk 2.0  (ffff:5678)
  device descriptor (18 bytes)
    1201000200000040FFFF7856000201020301
    usb 2.00   vendor ffff   product 5678   class 00   max packet 64
  configuration descriptor, 32 bytes total
    interface 0 alt 0  class 08/06/50
      endpoint 0x01  Bulk        512 bytes
      endpoint 0x82  Bulk        512 bytes

The import path was then checked the same way. With a virtual controller installed, nksusb attach handed the same flash drive to the virtual machine's own USB stack: Windows enumerated it, bound its ordinary mass storage driver, and mounted the filesystem as a removable drive. Files written from the virtual machine landed on the physical device, and a two megabyte round trip came back byte for byte identical.

Architecture

   machine A (host)                              machine B (client)
   +-----------------------+                     +-----------------------+
   | USB device            |                     | application           |
   |   |  WinUSB / usbfs   |                     |   ^  RemoteUsbDevice  |
   |   v                   |   TLS 1.3, port     |   |                   |
   | NodeService           |                     | NodeService           |
   |   HostServer  --------+------  57340  ------+-> UsbShareClient      |
   +-----------------------+                     +-----------------------+

Transfers cross the link as URBs: the client submits a request describing an endpoint, a transfer type and a payload; the host issues it through the operating system and sends back the result. Control, bulk and interrupt transfers are carried; isochronous is carried by the protocol and implemented on the Linux backend.

Components

| Component | Runtime | Description | |-----------|---------|-------------| | NksUsbShare.Core | .NET 9 | Wire protocol, TLS, USB backends, host and client engines | | NksUsbShare.Cli | .NET 9 | nksusb command line with every feature, all platforms | | NksUsbShare.Desktop | .NET 9 (WPF) | Windows application | | NksUsbShare.Gtk | .NET 9 (GTK 3) | Linux application, plain P/Invoke | | NksUsbShare.Mac | .NET 9 (AppKit) | macOS application, on the Objective-C runtime | | NksUsbShare.Mcp | .NET 9 | Management server speaking the Model Context Protocol |

Security

| Layer | Technology | Scope | |-------|-----------|-------| | Transport | TLS 1.3 (TLS 1.2 floor) | Every connection, before a single protocol byte | | Host identity | Self-signed P-384, pinned on first use | Client refuses a host whose key changed | | Client identity | Self-signed P-384, always presented | Host names, blocks and restricts by key | | Admission | 125-bit pairing token, constant-time compare | Every connection | | Per device | Allow list of client fingerprints | Listing and opening |

  • Public-key pinning. Each node generates its certificate on first run. A client pins the host's fingerprint the first time it connects and refuses to continue if it ever changes. There is no certificate authority, because there is no third party in the link.
  • Pairing tokens. 125 bits of entropy, shown in groups of five characters with the ambiguous ones removed so they can be read aloud.
  • Every client is named. A client always presents its own key, so the host records which computers have used it and can tell them apart. Nothing has to be turned on for this.
  • Blocking. A computer can be refused outright. It is disconnected at once and anything it was holding is released, so blocking does not wait for it to come ba

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars3
CategoryDevelopment
Updated1mo ago
Forks1

Languages

C#

Trust signals

80/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium1 low