RemoteViewer.DeviceKit.Files 0.9.9

DeviceKit

"ConnectKit gives you the pipe. DeviceKit gives you the protocol."

DeviceKit is the application-protocol layer that rides ConnectKit's end-to-end-encrypted pipe. ConnectKit guarantees an authenticated, NAT-traversing byte channel and deliberately leaves what rides it to you. DeviceKit fills that in — once, OS-independently — for the domains that aren't remote-desktop: IoT, RMM, robotics, and industrial.

// You already have a ConnectKit channel (the pipe):
await using var ck = new ConnectKitClient(new ConnectKitOptions { Secret = "s3cr3t", /* … */ });
await using var channel = await ck.ConnectAsync("device-1");

// DeviceKit layers structure on top:
await using var peer = channel.ToDevicePeer();               // via DeviceKit.ConnectKit adapter

var info = await peer.CallAsync<InfoReq, InfoResp>("sys.info", new InfoReq());   // RPC
peer.Subscribe<Reading>("telemetry/temp", r => Log(r));                          // pub/sub
peer.Publish("telemetry/temp", new Reading(21.4, DateTimeOffset.Now));

The core references nothing but the BCL — no P/Invoke, no platform APIs, no native dependencies — so it runs anywhere .NET does. The ConnectKit binding lives in a separate adapter package, and the core is unit-tested with an in-memory channel (no server, no socket, no OS).

Install

dotnet add package RemoteViewer.DeviceKit             # the core (RPC / streaming / pub-sub / presence / sub-channels)
dotnet add package RemoteViewer.DeviceKit.ConnectKit  # ride a ConnectKit end-to-end-encrypted pipe

Add only the profiles/bridges you need: RemoteViewer.DeviceKit. Iot · Rmm · Robotics · Industrial · Files · Codec.Cbor · Bridge.Mqtt · Bridge.OpcUa · Bridge.Dds.

Targets net8.0 and net9.0. v0.9.9 — release candidate for 1.0. DeviceKit is commercial software (see LICENSE.txt); the client libraries are free, and installation requires accepting the license. New here? Follow the 5-minute quickstart in GETTING-STARTED.md.

What you get

Open extension model

New domains plug in through IPeerExtension (+ IMessageInterceptor, ICodec) with zero core changes — and the built-ins use the very same seams. Four profiles ship as optional packages, all built purely on the public API:

• DeviceKit.Iot: typed telemetry streams and a device twin (desired state from the app, reported state from the device) — Azure/AWS-shadow-flavored, brokerless.
• DeviceKit.Rmm: device inventory (RPC), live metrics (pub/sub), and remote command execution with streamed output and an exit result (streaming RPC).
• DeviceKit.Robotics (ROS 2 / DDS-flavored): Actions (goal → feedback stream → result, cancelable), Services, typed Topics with QoS hints.
• DeviceKit.Industrial (OPC-UA / Sparkplug-flavored): a tag address space (read/write/subscribe/browse), methods, and alarms.

peer.Use(new IotExtension());
peer.Use(new RmmExtension());
peer.Use(new RoboticsExtension());
peer.Use(new IndustrialExtension());
peer.Use(new MyOwnDomainExtension());   // third parties, same way

Low-bandwidth links

The default codec is JSON (great DX). For constrained/low-bandwidth links, drop in the optional DeviceKit.Codec.Cbor (CBOR / RFC 8949, the CoAP/LwM2M payload format) — one line, on both peers, wire header unchanged:

var peer = new DevicePeer(channel, new DevicePeerOptions { Codec = new CborCodec() });

Interop with existing MQTT infrastructure

Bridge DeviceKit's pub/sub to an external MQTT broker with the optional DeviceKit.Bridge.Mqtt — relay matching topics both ways, so a DeviceKit peer coexists with brownfield MQTT assets:

var link = new MqttNetLink(new MqttConnection { Host = "broker.local" });
var opts = new MqttBridgeOptions().ForwardDevicePrefix("sensor/").SubscribeMqtt("cmd/#");
await using var bridge = await MqttBridge.StartAsync(peer, link, opts);

Layout

src/DeviceKit/               core SDK (BCL only) — messaging/wire, DevicePeer, RPC, PubSub, Presence, extension seams
src/DeviceKit.ConnectKit/    the only project that references ConnectKit — IConnectChannel → IMessageChannel adapter
src/DeviceKit.Iot/           IoT profile (telemetry + device twin)
src/DeviceKit.Rmm/           RMM profile (inventory + metrics + remote exec)
src/DeviceKit.Robotics/      robotics profile (actions/services/topics)
src/DeviceKit.Industrial/    industrial profile (tag space/methods/alarms)
src/DeviceKit.Codec.Cbor/    optional CBOR codec for low-bandwidth links
src/DeviceKit.Bridge.Mqtt/   optional MQTT bridge — relay topics to/from an external broker (brownfield interop)
src/DeviceKit.Bridge.OpcUa/  optional OPC-UA bridge — back the industrial address space with a real OPC-UA server
src/DeviceKit.Bridge.Dds/    optional DDS bridge — relay topics to/from a DDS domain (ROS 2 interop); BYO vendor via IDdsLink
samples/DeviceKit.Sample/            self-contained in-memory loopback demo (four domains in one process)
samples/DeviceKit.Sample.ConnectKit/ end-to-end over a real ConnectKit E2E socket (direct TCP loopback)
samples/DeviceKit.Sample.EdgeReach/  one connection carrying control + config-push + firmware + a session sub-channel
tests/DeviceKit.Tests/       NUnit (54) — envelope codec, RPC, streaming, pub/sub, presence, sub-channels, all profiles, files, config, bridges, CBOR
docs/DESIGN.md               the design document

Build & run

dotnet build DeviceKit.slnx -c Release
dotnet test  DeviceKit.slnx -c Release
dotnet run --project samples/DeviceKit.Sample -c Release

Requires the .NET 8 or 9 SDK. The core multi-targets net8.0;net9.0. Pricing follows the family model: the DeviceKit client is free, like ConnectKit — connection and its protocol layer are never the paywall.

Docs

• GETTING-STARTED.md — 5-minute quickstart (app ↔ device over ConnectKit).
• docs/USAGE.md — cookbook: every capability and profile with copy-paste examples.
• docs/DESIGN.md — architecture, wire protocol, open extension model, roadmap.
• docs/STANDARDS.md — how much of MQTT/CoAP/OPC-UA/DDS/Sparkplug is reflected, and the gaps.
• docs/MARKET.md — objective demand & competitive assessment.
• docs/API.md — the public surface (0.9.9, the 1.0 release candidate), per package.
• docs/WIRE-PROTOCOL.md — language-neutral wire spec for non-.NET bindings.
• docs/BRIDGES.md — MQTT/OPC-UA/DDS bridge integration, vendor adapters, validation.

Part of the RemoteViewer Kit family: ConnectKit (pipe) · SessionKit (remote-desktop) · ServerKit (server) · DeviceKit (IoT/RMM/robotics/industrial).