Build Your Own Client

use rumqttc::{MqttOptions, AsyncClient, QoS, Event, Packet, LastWill};
use serde_json::{json, Value};
use tokio;

#[tokio::main]
async fn main() {
    let agent_id = "baseAgent_agent_abc123";
    let device_name = "rust-sensor";
    let device_credential = "your-device-credential";
    let prefix = format!("lua/devices/{agent_id}/{device_name}/");

    let mut opts = MqttOptions::new(
        format!("lua-{agent_id}-{device_name}"),
        "wss://mqtt.heylua.ai/mqtt", 443,
    );
    opts.set_credentials(format!("{agent_id}:{device_name}"), device_credential);
    opts.set_keep_alive(std::time::Duration::from_secs(60));
    opts.set_clean_session(false);
    opts.set_last_will(LastWill::new(
        format!("{prefix}status"),
        json!({"status": "offline"}).to_string(),
        QoS::AtLeastOnce, true,
    ));
    opts.set_transport(rumqttc::Transport::tls_with_default_config());

    let (client, mut eventloop) = AsyncClient::new(opts, 10);
    client.subscribe(format!("{prefix}command"), QoS::AtLeastOnce).await.unwrap();

    // Publish online status
    let online = json!({"status": "online"}).to_string();
    client.publish(format!("{prefix}status"), QoS::AtLeastOnce, true, online).await.unwrap();
    let manifest = json!({"status": "online", "commands": []}).to_string();
    client.publish(format!("{prefix}status"), QoS::AtLeastOnce, false, manifest).await.unwrap();

    println!("Device connected. Listening for commands...");
    while let Ok(event) = eventloop.poll().await {
        if let Event::Incoming(Packet::Publish(msg)) = event {
            if msg.topic.ends_with("/command") {
                let cmd: Value = serde_json::from_slice(&msg.payload).unwrap();
                let response = json!({
                    "commandId": cmd["commandId"],
                    "success": true,
                    "data": {"temp": 22.5}
                });
                client.publish(
                    format!("{prefix}response"), QoS::AtLeastOnce, false,
                    response.to_string(),
                ).await.unwrap();
            }
        }
    }
}

using MQTTnet;
using MQTTnet.Client;
using System.Text;
using System.Text.Json;

var agentId = "baseAgent_agent_abc123";
var deviceName = "csharp-sensor";
var deviceCredential = "your-device-credential";
var prefix = $"lua/devices/{agentId}/{deviceName}/";

var factory = new MqttFactory();
var client = factory.CreateMqttClient();

var options = new MqttClientOptionsBuilder()
    .WithTcpServer("wss://mqtt.heylua.ai/mqtt", 443)
    .WithTlsOptions(o => o.UseTls())
    .WithClientId($"lua-{agentId}-{deviceName}")
    .WithCredentials($"{agentId}:{deviceName}", deviceCredential)
    .WithKeepAlivePeriod(TimeSpan.FromSeconds(60))
    .WithCleanSession(false)
    .WithWillTopic($"{prefix}status")
    .WithWillPayload(JsonSerializer.Serialize(new { status = "offline" }))
    .WithWillQualityOfServiceLevel(MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce)
    .WithWillRetain(true)
    .Build();

client.ApplicationMessageReceivedAsync += async e =>
{
    if (e.ApplicationMessage.Topic.EndsWith("/command"))
    {
        var cmd = JsonSerializer.Deserialize<JsonElement>(e.ApplicationMessage.PayloadSegment);
        var response = JsonSerializer.Serialize(new
        {
            commandId = cmd.GetProperty("commandId").GetString(),
            success = true,
            data = new { temp = 22.5 }
        });
        await client.PublishStringAsync($"{prefix}response", response,
            MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce);
    }
};

await client.ConnectAsync(options);
await client.SubscribeAsync($"{prefix}command",
    MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce);

// Publish online status
await client.PublishStringAsync($"{prefix}status",
    JsonSerializer.Serialize(new { status = "online" }),
    MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce, true);
await client.PublishStringAsync($"{prefix}status",
    JsonSerializer.Serialize(new { status = "online", commands = Array.Empty<object>() }),
    MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce, false);

Console.WriteLine("Device connected. Press Ctrl+C to exit.");
await Task.Delay(Timeout.Infinite);

import MQTTNIO
import NIO
import Foundation

let agentId = "baseAgent_agent_abc123"
let deviceName = "swift-sensor"
let deviceCredential = "your-device-credential"
let prefix = "lua/devices/\(agentId)/\(deviceName)/"

let client = MQTTClient(
    configuration: .init(
        target: .webSocket("wss://mqtt.heylua.ai/mqtt"),
        tls: .forClient(certificateVerification: .fullVerification),
        clientId: "lua-\(agentId)-\(deviceName)",
        clean: false,
        credentials: .init(
            username: "\(agentId):\(deviceName)",
            password: deviceCredential
        ),
        willMessage: .init(
            topic: "\(prefix)status",
            payload: ByteBuffer(string: #"{"status":"offline"}"#),
            qos: .atLeastOnce,
            retain: true
        ),
        keepAliveInterval: .seconds(60)
    ),
    eventLoopGroupProvider: .createNew
)

try client.connect().wait()
try client.subscribe(to: [.init(topicFilter: "\(prefix)command", qos: .atLeastOnce)]).wait()

// Publish online status
let online = #"{"status":"online"}"#
try client.publish(.init(topic: "\(prefix)status",
    payload: ByteBuffer(string: online), qos: .atLeastOnce, retain: true)).wait()
let manifest = #"{"status":"online","commands":[]}"#
try client.publish(.init(topic: "\(prefix)status",
    payload: ByteBuffer(string: manifest), qos: .atLeastOnce, retain: false)).wait()

client.addPublishListener(named: "commands") { result in
    if case .success(let msg) = result, msg.topic.hasSuffix("/command") {
        guard let data = msg.payload.getData(at: 0, length: msg.payload.readableBytes),
              let cmd = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
              let commandId = cmd["commandId"] as? String else { return }

        let response: [String: Any] = [
            "commandId": commandId, "success": true,
            "data": ["temp": 22.5]
        ]
        let payload = try! JSONSerialization.data(withJSONObject: response)
        _ = try? client.publish(.init(topic: "\(prefix)response",
            payload: ByteBuffer(data: payload), qos: .atLeastOnce, retain: false)).wait()
    }
}

print("Device connected. Listening for commands...")
dispatchMain()