// scmd.c — Steam Controller / Puck feature-report command tool (macOS IOKit).
// Talks to the VENDOR HID interface (usage page 0xFF00) which opens WITHOUT
// Input Monitoring permission. Implements the 64-byte SET_REPORT(command) plus
// GET_REPORT(reply) command channel observed on the Triton copycat/real puck.
//
//   clang -framework IOKit -framework CoreFoundation -o scmd scmd.c
//   ./scmd list [pidHex]            # list Valve HID nodes and serials
//   ./scmd <pidHex> [--serial S] [--loc HEX]    # run the SAFE read battery (no writes)
//   ./scmd <pidHex> [--serial S] [--loc HEX] <cmdHex> [payloadHexBytes...]   # one custom command
//   ./scmd <pidHex> [--serial S] [--loc HEX] rid2 <cmdHex> [payloadHexBytes...] # custom command on one report id
//   ./scmd <pidHex> [--serial S] [--loc HEX] seq-noget rid2 <cmd> [bytes...] -- rid2 <cmd> [bytes...]
//   ./scmd <pidHex> [--serial S] [--loc HEX] a3watch [count] [delayMs] # watch/decode Triton A3 bond events
//   ./scmd <pidHex> [--serial S] [--loc HEX] a3variants # read-only A3 framing tests
//   ./scmd <pidHex> [--serial S] [--loc HEX] triton-bond <0|1> <keyHex16> <peerSerial>
//   ./scmd <pidHex> [--serial S] [--loc HEX] triton-transport <slot0|slot1|slot2|rawByte>
//
// SAFE reads used by default: 0xAE GET_STRING_ATTRIBUTE (serials), 0x83
// GET_ATTRIBUTES_VALUES, 0xA1 GET_DEVICE_INFO, 0xB4 DONGLE_GET_WIRELESS_STATE.
//
// Command labels below are only labels. 0xA2/0xA3 are Triton-confirmed from our
// copycat logs; the 0xAF..0xC4 names come from SDL's shared Steam constants and
// are not proof of Triton pairing semantics. Destructive opcodes (0x86 reset,
// 0x9F off, 0xAD pair, 0xB2/B3 dongle candidates, 0xAF/B0 radio-record
// candidates) are NEVER sent unless you pass them explicitly.
#include <IOKit/hid/IOHIDManager.h>
#include <IOKit/IOKitLib.h>
#include <CoreFoundation/CoreFoundation.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define VALVE_VID 0x28DE

static void dump(const char *label, const uint8_t *p, int n) {
    printf("%s [%d]:\n  ", label, n);
    for (int i = 0; i < n; i++) { if (i && i % 32 == 0) printf("\n  "); printf("%02X ", p[i]); }
    printf("\n  ascii: ");
    for (int i = 0; i < n; i++) putchar((p[i] >= 32 && p[i] < 127) ? p[i] : '.');
    printf("\n");
}

static void print_payload_inline(const uint8_t *p, int n) {
    if (n <= 0) {
        printf("-");
        return;
    }
    for (int i = 0; i < n; i++) {
        if (i) printf(" ");
        printf("%02X", p[i]);
    }
}

static const char *cmd_name(uint8_t cmd) {
    switch (cmd) {
        case 0x83: return "GET_ATTRIBUTES_VALUES";
        case 0xA1: return "GET_DEVICE_INFO";
        case 0xA2: return "TRITON_A2_OBSERVED_PAIRING_RECORD";
        case 0xA3: return "TRITON_A3_BOND_EVENT_OR_STATUS";
        case 0xAD: return "ENABLE_PAIRING";
        case 0xAE: return "GET_STRING_ATTRIBUTE";
        case 0xAF: return "SDL_SHARED_RADIO_ERASE_RECORDS";
        case 0xB0: return "SDL_SHARED_RADIO_WRITE_RECORD";
        case 0xB2: return "SDL_SHARED_DONGLE_DISCONNECT_DEVICE";
        case 0xB3: return "SDL_SHARED_DONGLE_COMMIT_DEVICE_CANDIDATE";
        case 0xB4: return "SDL_SHARED_DONGLE_GET_WIRELESS_STATE";
        case 0xC4: return "SDL_SHARED_DONGLE_GET_CONNECTED_SLOTS";
        case 0xEE: return "TRITON_KEYED_VALUE_WRITE";
        case 0xEF: return "TRITON_KEYED_VALUE_COMMIT";
        default: return NULL;
    }
}

static int hid_long(IOHIDDeviceRef d, CFStringRef key, long *out) {
    CFTypeRef v = IOHIDDeviceGetProperty(d, key);
    if (!v || CFGetTypeID(v) != CFNumberGetTypeID()) return 0;
    return CFNumberGetValue((CFNumberRef)v, kCFNumberLongType, out);
}

static void hid_string(IOHIDDeviceRef d, CFStringRef key, char *out, size_t outn) {
    if (!outn) return;
    out[0] = 0;
    CFTypeRef v = IOHIDDeviceGetProperty(d, key);
    if (!v) return;
    if (CFGetTypeID(v) == CFStringGetTypeID()) {
        CFStringGetCString((CFStringRef)v, out, outn, kCFStringEncodingUTF8);
    } else if (CFGetTypeID(v) == CFNumberGetTypeID()) {
        long x = 0;
        if (CFNumberGetValue((CFNumberRef)v, kCFNumberLongType, &x)) snprintf(out, outn, "%ld", x);
    }
}

static int reg_long(io_object_t svc, const char *key, long *out) {
    CFStringRef k = CFStringCreateWithCString(kCFAllocatorDefault, key, kCFStringEncodingUTF8);
    if (!k) return 0;
    CFTypeRef v = IORegistryEntryCreateCFProperty(svc, k, kCFAllocatorDefault, 0);
    CFRelease(k);
    if (!v) return 0;
    int ok = 0;
    if (CFGetTypeID(v) == CFNumberGetTypeID()) ok = CFNumberGetValue((CFNumberRef)v, kCFNumberLongType, out);
    CFRelease(v);
    return ok;
}

static void reg_string(io_object_t svc, const char *key, char *out, size_t outn) {
    if (!outn) return;
    out[0] = 0;
    CFStringRef k = CFStringCreateWithCString(kCFAllocatorDefault, key, kCFStringEncodingUTF8);
    if (!k) return;
    CFTypeRef v = IORegistryEntryCreateCFProperty(svc, k, kCFAllocatorDefault, 0);
    CFRelease(k);
    if (!v) return;
    if (CFGetTypeID(v) == CFStringGetTypeID()) {
        CFStringGetCString((CFStringRef)v, out, outn, kCFStringEncodingUTF8);
    } else if (CFGetTypeID(v) == CFNumberGetTypeID()) {
        long x = 0;
        if (CFNumberGetValue((CFNumberRef)v, kCFNumberLongType, &x)) snprintf(out, outn, "%ld", x);
    }
    CFRelease(v);
}

static void print_device_line(io_object_t svc, IOHIDDeviceRef d) {
    long vid = -1, pid = -1, up = -1, usage = -1, loc = -1, maxF = -1;
    char serial[128], product[128], manufacturer[128];
    serial[0] = product[0] = manufacturer[0] = 0;
    reg_long(svc, "VendorID", &vid); if (vid < 0) hid_long(d, CFSTR(kIOHIDVendorIDKey), &vid);
    reg_long(svc, "ProductID", &pid); if (pid < 0) hid_long(d, CFSTR(kIOHIDProductIDKey), &pid);
    reg_long(svc, "PrimaryUsagePage", &up); if (up < 0) hid_long(d, CFSTR(kIOHIDPrimaryUsagePageKey), &up);
    reg_long(svc, "PrimaryUsage", &usage); if (usage < 0) hid_long(d, CFSTR(kIOHIDPrimaryUsageKey), &usage);
    reg_long(svc, "LocationID", &loc); if (loc < 0) hid_long(d, CFSTR(kIOHIDLocationIDKey), &loc);
    reg_long(svc, "MaxFeatureReportSize", &maxF);
    reg_string(svc, "SerialNumber", serial, sizeof serial); if (!serial[0]) hid_string(d, CFSTR(kIOHIDSerialNumberKey), serial, sizeof serial);
    reg_string(svc, "Product", product, sizeof product); if (!product[0]) hid_string(d, CFSTR(kIOHIDProductKey), product, sizeof product);
    reg_string(svc, "Manufacturer", manufacturer, sizeof manufacturer); if (!manufacturer[0]) hid_string(d, CFSTR(kIOHIDManufacturerKey), manufacturer, sizeof manufacturer);
    printf("Valve %04lX:%04lX usagePage=0x%lX usage=0x%lX maxFeature=%ld loc=0x%lX serial=%s product=%s manufacturer=%s\n",
           vid, pid, up, usage, maxF, loc, serial[0] ? serial : "-", product[0] ? product : "-",
           manufacturer[0] ? manufacturer : "-");
}

static int list_devices(long wantPid) {
    CFMutableDictionaryRef m = IOServiceMatching("IOHIDDevice");
    io_iterator_t it;
    if (IOServiceGetMatchingServices(kIOMainPortDefault, m, &it) != KERN_SUCCESS) {
        fprintf(stderr, "match fail\n");
        return 1;
    }
    int n = 0;
    io_object_t svc;
    while ((svc = IOIteratorNext(it))) {
        IOHIDDeviceRef d = IOHIDDeviceCreate(kCFAllocatorDefault, svc);
        if (d) {
            long vid = -1, pid = -1;
            reg_long(svc, "VendorID", &vid); if (vid < 0) hid_long(d, CFSTR(kIOHIDVendorIDKey), &vid);
            reg_long(svc, "ProductID", &pid); if (pid < 0) hid_long(d, CFSTR(kIOHIDProductIDKey), &pid);
            if (vid == VALVE_VID && (wantPid < 0 || pid == wantPid)) {
                print_device_line(svc, d);
                n++;
            }
            CFRelease(d);
        }
        IOObjectRelease(svc);
    }
    IOObjectRelease(it);
    if (!n) printf("no Valve HID devices found%s\n", wantPid < 0 ? "" : " for requested PID");
    return n ? 0 : 1;
}

// Issue one command on report id `rid`: [rid][cmd][len][payload...].
static void sc_cmd_ex(IOHIDDeviceRef d, int rid, uint8_t cmd, const uint8_t *pl, int pln, int do_get) {
    uint8_t tx[64]; memset(tx, 0, sizeof tx);
    tx[0] = (uint8_t)rid; tx[1] = cmd; tx[2] = (uint8_t)pln;
    if (pln > 0) memcpy(tx + 3, pl, pln);
    IOReturn rs = IOHIDDeviceSetReport(d, kIOHIDReportTypeFeature, rid, tx, 64);
    const char *name = cmd_name(cmd);
    if (rs != kIOReturnSuccess) {
        printf("\n=== cmd 0x%02X%s%s (payload %d: ", cmd, name ? " " : "", name ? name : "", pln);
        print_payload_inline(pl, pln);
        printf(") on report id %d  [set=0x%08X get=skipped-set-failed] ===\n", rid, rs);
        return;
    }
    if (!do_get) {
        printf("\n=== cmd 0x%02X%s%s (payload %d: ", cmd, name ? " " : "", name ? name : "", pln);
        print_payload_inline(pl, pln);
        printf(") on report id %d  [set=0x%08X get=skipped] ===\n", rid, rs);
        return;
    }
    usleep(20000);
    uint8_t rx[64]; memset(rx, 0, sizeof rx); rx[0] = (uint8_t)rid;
    CFIndex rl = 64;
    IOReturn rg = IOHIDDeviceGetReport(d, kIOHIDReportTypeFeature, rid, rx, &rl);
    printf("\n=== cmd 0x%02X%s%s (payload %d: ", cmd, name ? " " : "", name ? name : "", pln);
    print_payload_inline(pl, pln);
    printf(") on report id %d  [set=0x%08X get=0x%08X] ===\n", rid, rs, rg);
    if (rg == kIOReturnSuccess) dump("reply", rx, (int)rl);
    else printf("  (GET failed)\n");
}

static void sc_cmd(IOHIDDeviceRef d, int rid, uint8_t cmd, const uint8_t *pl, int pln) {
    sc_cmd_ex(d, rid, cmd, pl, pln, 1);
}

static int hex_value(char c) {
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    return -1;
}

static int parse_hex_bytes(const char *hex, uint8_t *out, int outn) {
    int n = 0;
    int hi = -1;
    for (const char *p = hex; *p; p++) {
        if (*p == ':' || *p == '-' || *p == ' ' || *p == '_') continue;
        int v = hex_value(*p);
        if (v < 0) return -1;
        if (hi < 0) {
            hi = v;
        } else {
            if (n >= outn) return -1;
            out[n++] = (uint8_t)((hi << 4) | v);
            hi = -1;
        }
    }
    if (hi >= 0) return -1;
    return n;
}

static int make_serial16(const char *serial, uint8_t out[16]) {
    memset(out, 0, 16);
    size_t n = strlen(serial);
    if (n > 16) return 0;
    memcpy(out, serial, n);
    return 1;
}

static int triton_keyed_write(IOHIDDeviceRef dev, const char *key, const uint8_t *payload, int payload_len) {
    size_t key_len = strlen(key) + 1;
    if (key_len + (size_t)payload_len > 61 || key_len > 61) {
        fprintf(stderr, "keyed payload too long for 64-byte feature report\n");
        return 2;
    }

    uint8_t ee[61];
    memcpy(ee, key, key_len);
    if (payload_len > 0) memcpy(ee + key_len, payload, payload_len);

    uint8_t ef[61];
    memcpy(ef, key, key_len);

    printf("Triton keyed write key=\"%s\" payload=", key);
    print_payload_inline(payload, payload_len);
    printf("\n");
    sc_cmd_ex(dev, 2, 0xEE, ee, (int)key_len + payload_len, 0);
    usleep(20000);
    sc_cmd_ex(dev, 2, 0xEF, ef, (int)key_len, 0);
    return 0;
}

static int triton_bond_write(IOHIDDeviceRef dev, int slot, const char *key_hex, const char *serial) {
    if (slot < 0 || slot > 1) {
        fprintf(stderr, "triton-bond slot must be 0 or 1\n");
        return 2;
    }
    uint8_t payload[24];
    int keyn = parse_hex_bytes(key_hex, payload, 8);
    if (keyn != 8) {
        fprintf(stderr, "triton-bond key must be exactly 8 bytes / 16 hex digits\n");
        return 2;
    }
    if (!make_serial16(serial, payload + 8)) {
        fprintf(stderr, "controller serial must be at most 16 ASCII bytes\n");
        return 2;
    }
    const char *key = slot == 0 ? "esb/bond" : "esb/bond_2";
    printf("note: Steam uses this keyed path for controller-side bond storage; real pucks reject it.\n");
    return triton_keyed_write(dev, key, payload, sizeof payload);
}

static int parse_triton_transport(const char *arg, uint8_t *out) {
    if (strcmp(arg, "slot0") == 0 || strcmp(arg, "0") == 0) { *out = 2; return 1; }
    if (strcmp(arg, "slot1") == 0 || strcmp(arg, "1") == 0) { *out = 3; return 1; }
    if (strcmp(arg, "slot2") == 0 || strcmp(arg, "2") == 0) { *out = 0; return 1; }
    char *end = NULL;
    long raw = strtol(arg, &end, 0);
    if (end && *end == 0 && raw >= 0 && raw <= 255) { *out = (uint8_t)raw; return 1; }
    return 0;
}

static int triton_transport_write(IOHIDDeviceRef dev, const char *arg) {
    uint8_t value = 0;
    if (!parse_triton_transport(arg, &value)) {
        fprintf(stderr, "triton-transport expects slot0, slot1, slot2, or raw byte 0..255\n");
        return 2;
    }
    return triton_keyed_write(dev, "user/wireless_transport", &value, 1);
}

static void print_a3_decode(const uint8_t *rx, int rl) {
    if (rl < 3 || rx[1] != 0xA3) {
        printf("  not an A3 reply\n");
        return;
    }
    int len = rx[2];
    if (len != 0x18 || rl < 27) {
        printf("  A3 len=0x%02X (no bond payload)\n", len);
        return;
    }
    const uint8_t *key = rx + 3;
    const uint8_t *serial = rx + 11;
    uint32_t w0 = (uint32_t)key[0] | ((uint32_t)key[1] << 8) | ((uint32_t)key[2] << 16) | ((uint32_t)key[3] << 24);
    uint32_t w1 = (uint32_t)key[4] | ((uint32_t)key[5] << 8) | ((uint32_t)key[6] << 16) | ((uint32_t)key[7] << 24);
    printf("  A3 bond key=");
    for (int i = 0; i < 8; i++) printf("%s%02X", i ? " " : "", key[i]);
    printf(" steam_words=%X_%X serial=", w0, w1);
    for (int i = 0; i < 16 && serial[i]; i++) putchar((serial[i] >= 32 && serial[i] < 127) ? serial[i] : '.');
    printf("\n");
}

static void print_a3_decode_any(const uint8_t *rx, int rl) {
    if (rl >= 2 && rx[0] == 0xA3) {
        uint8_t shifted[64];
        int n = rl + 1;
        if (n > (int)sizeof shifted) n = (int)sizeof shifted;
        memset(shifted, 0, sizeof shifted);
        shifted[0] = 2;
        memcpy(shifted + 1, rx, n - 1);
        print_a3_decode(shifted, n);
        return;
    }
    print_a3_decode(rx, rl);
}

static int a3_watch(IOHIDDeviceRef dev, int count, int delay_ms) {
    if (count <= 0) count = 20;
    if (delay_ms < 0) delay_ms = 100;
    for (int i = 0; i < count; i++) {
        uint8_t tx[64]; memset(tx, 0, sizeof tx);
        tx[0] = 2; tx[1] = 0xA3; tx[2] = 0;
        IOReturn rs = IOHIDDeviceSetReport(dev, kIOHIDReportTypeFeature, 2, tx, 64);
        usleep(20000);
        uint8_t rx[64]; memset(rx, 0, sizeof rx); rx[0] = 2;
        CFIndex rl = 64;
        IOReturn rg = kIOReturnError;
        if (rs == kIOReturnSuccess) rg = IOHIDDeviceGetReport(dev, kIOHIDReportTypeFeature, 2, rx, &rl);
        printf("[%02d] A3 set=0x%08X get=0x%08X", i + 1, rs, rg);
        if (rg == kIOReturnSuccess && rl >= 3) printf(" reply=%02X %02X %02X", rx[0], rx[1], rx[2]);
        printf("\n");
        if (rg == kIOReturnSuccess) print_a3_decode(rx, (int)rl);
        if (delay_ms > 0 && i + 1 < count) usleep((useconds_t)delay_ms * 1000);
    }
    return 0;
}

static void a3_variant(IOHIDDeviceRef dev, const char *label, int include_rid, int set_len, int get_len, int seed_rid) {
    uint8_t tx[64]; memset(tx, 0, sizeof tx);
    if (include_rid) {
        tx[0] = 2;
        tx[1] = 0xA3;
        tx[2] = 0;
    } else {
        tx[0] = 0xA3;
        tx[1] = 0;
    }
    IOReturn rs = IOHIDDeviceSetReport(dev, kIOHIDReportTypeFeature, 2, tx, set_len);
    usleep(20000);
    uint8_t rx[64]; memset(rx, 0, sizeof rx);
    if (seed_rid) rx[0] = 2;
    CFIndex rl = get_len;
    IOReturn rg = kIOReturnError;
    if (rs == kIOReturnSuccess) rg = IOHIDDeviceGetReport(dev, kIOHIDReportTypeFeature, 2, rx, &rl);
    printf("\n=== A3 variant %s setLen=%d getLen=%d includeRid=%d seedRid=%d set=0x%08X get=0x%08X rl=%ld ===\n",
           label, set_len, get_len, include_rid, seed_rid, rs, rg, (long)rl);
    if (rg == kIOReturnSuccess) {
        dump("reply", rx, (int)rl);
        print_a3_decode_any(rx, (int)rl);
    }
}

static int a3_variants(IOHIDDeviceRef dev) {
    a3_variant(dev, "steam-short", 0, 2, 0x1a, 0);
    a3_variant(dev, "steam-short-seeded", 0, 2, 0x1a, 1);
    a3_variant(dev, "rid-short", 1, 3, 0x1b, 1);
    a3_variant(dev, "rid-64", 1, 64, 64, 1);
    return 0;
}

static int run_seq(IOHIDDeviceRef dev, int argc, char **argv, int start, int do_get) {
    int i = start;
    while (i < argc) {
        if (strcmp(argv[i], "--") == 0) { i++; continue; }
        if (strncmp(argv[i], "rid", 3) != 0) {
            fprintf(stderr, "seq expects ridN before each command, got: %s\n", argv[i]);
            return 2;
        }
        int rid = atoi(argv[i] + 3);
        if (rid < 1 || rid > 255) { fprintf(stderr, "bad report id: %s\n", argv[i]); return 2; }
        i++;
        if (i >= argc) { fprintf(stderr, "seq missing cmd after rid%d\n", rid); return 2; }
        uint8_t cmd = (uint8_t)strtol(argv[i++], NULL, 16);
        uint8_t pl[62]; int pln = 0;
        while (i < argc && strcmp(argv[i], "--") != 0) {
            if (strncmp(argv[i], "rid", 3) == 0) break;
            if (pln >= 62) { fprintf(stderr, "payload too long for cmd 0x%02X\n", cmd); return 2; }
            pl[pln++] = (uint8_t)strtol(argv[i++], NULL, 16);
        }
        sc_cmd_ex(dev, rid, cmd, pl, pln, do_get);
        usleep(20000);
    }
    return 0;
}

int main(int argc, char **argv) {
    if (argc < 2) { fprintf(stderr, "usage: %s list [pidHex] | <pidHex> [--serial SERIAL] [cmdHex payloadBytes...]\n", argv[0]); return 2; }
    if (strcmp(argv[1], "list") == 0) {
        long wantPid = argc >= 3 ? strtol(argv[2], NULL, 16) : -1;
        return list_devices(wantPid);
    }
    long wantPid = strtol(argv[1], NULL, 16);
    const char *wantSerial = NULL;
    long wantLoc = -1;
    long wantUp = -1;
    int wantIdx = -1;
    int matchIdx = 0;
    int arg = 2;
    while (arg < argc) {
        if (strcmp(argv[arg], "--serial") == 0) {
            if (arg + 1 >= argc) { fprintf(stderr, "--serial needs a value\n"); return 2; }
            wantSerial = argv[arg + 1];
            arg += 2;
        } else if (strncmp(argv[arg], "--serial=", 9) == 0) {
            wantSerial = argv[arg] + 9;
            arg++;
        } else if (strcmp(argv[arg], "--loc") == 0) {
            if (arg + 1 >= argc) { fprintf(stderr, "--loc needs a value\n"); return 2; }
            wantLoc = strtol(argv[arg + 1], NULL, 0);
            arg += 2;
        } else if (strncmp(argv[arg], "--loc=", 6) == 0) {
            wantLoc = strtol(argv[arg] + 6, NULL, 0);
            arg++;
        } else if (strcmp(argv[arg], "--up") == 0) {
            if (arg + 1 >= argc) { fprintf(stderr, "--up needs a value\n"); return 2; }
            wantUp = strtol(argv[arg + 1], NULL, 0);
            arg += 2;
        } else if (strcmp(argv[arg], "--idx") == 0) {
            if (arg + 1 >= argc) { fprintf(stderr, "--idx needs a value\n"); return 2; }
            wantIdx = strtol(argv[arg + 1], NULL, 0);
            arg += 2;
        } else {
            break;
        }
    }

    CFMutableDictionaryRef m = IOServiceMatching("IOHIDDevice");
    io_iterator_t it;
    if (IOServiceGetMatchingServices(kIOMainPortDefault, m, &it) != KERN_SUCCESS) { fprintf(stderr, "match fail\n"); return 1; }

    IOHIDDeviceRef dev = NULL; io_object_t svc;
    while ((svc = IOIteratorNext(it))) {
        CFTypeRef vid = IORegistryEntryCreateCFProperty(svc, CFSTR("VendorID"), kCFAllocatorDefault, 0);
        CFTypeRef pid = IORegistryEntryCreateCFProperty(svc, CFSTR("ProductID"), kCFAllocatorDefault, 0);
        long v = -1, p = -1;
        if (vid) { CFNumberGetValue((CFNumberRef)vid, kCFNumberLongType, &v); CFRelease(vid); }
        if (pid) { CFNumberGetValue((CFNumberRef)pid, kCFNumberLongType, &p); CFRelease(pid); }
        if (v == VALVE_VID && p == wantPid) {
            IOHIDDeviceRef d = IOHIDDeviceCreate(kCFAllocatorDefault, svc);
            long up = -1, maxF = -1, loc = -1;
            if (d) {
                reg_long(svc, "PrimaryUsagePage", &up);
                if (up < 0) {
                    CFTypeRef u = IOHIDDeviceGetProperty(d, CFSTR(kIOHIDPrimaryUsagePageKey));
                    if (u) CFNumberGetValue((CFNumberRef)u, kCFNumberLongType, &up);
                }
                reg_long(svc, "MaxFeatureReportSize", &maxF);
                reg_long(svc, "LocationID", &loc);
            }
            char serial[128] = "";
            char product[128] = "";
            if (d) {
                reg_string(svc, "SerialNumber", serial, sizeof serial);
                if (!serial[0]) hid_string(d, CFSTR(kIOHIDSerialNumberKey), serial, sizeof serial);
                reg_string(svc, "Product", product, sizeof product);
                if (!product[0]) hid_string(d, CFSTR(kIOHIDProductKey), product, sizeof product);
            }
            if (wantSerial && strcmp(wantSerial, serial) != 0) {
                if (d) CFRelease(d);
                IOObjectRelease(svc);
                continue;
            }
            if (wantLoc >= 0 && loc != wantLoc) {
                if (d) CFRelease(d);
                IOObjectRelease(svc);
                continue;
            }
            if (wantUp >= 0 && up != wantUp) {
                if (d) CFRelease(d);
                IOObjectRelease(svc);
                continue;
            }
            if (wantIdx >= 0 && matchIdx++ != wantIdx) {
                if (d) CFRelease(d);
                IOObjectRelease(svc);
                continue;
            }
            int command_capable = (up == 0xFF00) || (maxF >= 64);
            IOReturn ro = d && command_capable ? IOHIDDeviceOpen(d, kIOHIDOptionsTypeNone) : kIOReturnNotFound;
            if (d && command_capable && ro == kIOReturnSuccess) {
                printf("opened Valve %04lX:%04lX node (usagePage=0x%lX maxFeature=%ld serial=%s product=%s)\n",
                       (long)VALVE_VID, wantPid, up, maxF, serial[0] ? serial : "-", product[0] ? product : "-");
                dev = d; IOObjectRelease(svc); break;
            }
            if (d && command_capable && (wantSerial || wantLoc >= 0)) {
                fprintf(stderr, "matched Valve %04lX:%04lX usagePage=0x%lX maxFeature=%ld loc=0x%lX serial=%s but open failed: 0x%08X\n",
                        (long)VALVE_VID, wantPid, up, maxF, loc, serial[0] ? serial : "-", ro);
            }
            if (d) CFRelease(d);
        }
        IOObjectRelease(svc);
    }
    IOObjectRelease(it);
    if (!dev) {
        if (wantSerial || wantLoc >= 0) fprintf(stderr, "no openable Valve %04lX command-capable interface matching serial=%s loc=0x%lX (quit Steam? wrong device?)\n", wantPid, wantSerial ? wantSerial : "-", wantLoc);
        else fprintf(stderr, "no openable Valve %04lX command-capable interface (quit Steam? add --serial/--loc?)\n", wantPid);
        return 1;
    }

    if (arg < argc && strcmp(argv[arg], "slotwrite") == 0) {
        // Single-session dongle slot write: 0xAD 01 (enter pairing mode) -> 0xA2 <24-byte record>
        // -> 0xAD 00, all on the SAME open handle (Steam keeps one session; pairing mode resets on
        // close). record = [8-byte uuids][16-byte serial]; zeros-serial clears the matching slot.
        // first arg = report id (the ALT channel is report id 3); rest = 24-byte record
        int rid = (arg + 1 < argc) ? atoi(argv[arg + 1]) : 3;
        uint8_t rec[24]; memset(rec, 0, sizeof rec);
        int n = 0;
        for (int i = arg + 2; i < argc && n < 24; i++) rec[n++] = (uint8_t)strtol(argv[i], NULL, 16);
        uint8_t on[2] = {0x01, 0x00}, off[1] = {0x00};
        printf("# slotwrite rid%d: AD 01 -> A2 <24> -> AD 00 (one session)\n", rid);
        sc_cmd(dev, rid, 0xAD, on, 2);
        sc_cmd(dev, rid, 0xA2, rec, 24);
        sc_cmd(dev, rid, 0xAD, off, 1);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone); CFRelease(dev); return 0;
    } else if (arg < argc && strcmp(argv[arg], "pair") == 0) {
        // Steamless pairing (firmware-derived): 0xAD [mode=1][channel] enters RF pairing mode;
        // the puck then runs the pairing handshake autonomously. Channel 0 => firmware default
        // (0x3c). Put the controller in pairing via its key-chord, then we poll 0xA3 for the bond.
        uint8_t ch = (arg + 1 < argc) ? (uint8_t)strtol(argv[arg + 1], NULL, 16) : 0x00;
        uint8_t start[2] = { 0x01, ch };
        printf("# pair: entering pairing mode (0xAD 01 %02X).\n", ch);
        printf("# >>> Now put the controller into pairing via its key-chord. Polling 0xA3...\n");
        sc_cmd(dev, 2, 0xAD, start, 2);
        int rc = a3_watch(dev, 120, 200);          // ~24s: watch status for the controller to bond
        uint8_t stop[1] = { 0x00 };
        printf("# pair: exiting pairing mode (0xAD 00).\n");
        sc_cmd(dev, 2, 0xAD, stop, 1);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone); CFRelease(dev); return rc;
    } else if (arg < argc && strcmp(argv[arg], "stop") == 0) {
        uint8_t stop[1] = { 0x00 };                // exit pairing mode
        sc_cmd(dev, 2, 0xAD, stop, 1);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone); CFRelease(dev); return 0;
    } else if (arg < argc && strcmp(argv[arg], "info") == 0) {
        // Read identity + bond status without changing anything.
        printf("\n##### 0x83 attributes #####\n");        sc_cmd(dev, 2, 0x83, NULL, 0);
        printf("\n##### 0xAE strings (idx 0..7) #####\n"); for (int a = 0; a < 8; a++) { uint8_t aa = (uint8_t)a; sc_cmd(dev, 2, 0xAE, &aa, 1); }
        printf("\n##### 0xB4 wireless state #####\n");     sc_cmd(dev, 2, 0xB4, NULL, 0);
        printf("\n##### 0xA3 status / bond #####\n");      sc_cmd(dev, 2, 0xA3, NULL, 0);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone); CFRelease(dev); return 0;
    } else if (arg < argc && strcmp(argv[arg], "a3watch") == 0) {
        int count = (arg + 1 < argc) ? atoi(argv[arg + 1]) : 20;
        int delay_ms = (arg + 2 < argc) ? atoi(argv[arg + 2]) : 100;
        int rc = a3_watch(dev, count, delay_ms);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
        CFRelease(dev);
        return rc;
    } else if (arg < argc && strcmp(argv[arg], "a3variants") == 0) {
        int rc = a3_variants(dev);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
        CFRelease(dev);
        return rc;
    } else if (arg < argc && strcmp(argv[arg], "triton-bond") == 0) {
        if (arg + 3 >= argc) {
            fprintf(stderr, "usage: %s <pidHex> [--serial S] triton-bond <0|1> <keyHex16> <controllerSerial>\n", argv[0]);
            IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
            CFRelease(dev);
            return 2;
        }
        int slot = atoi(argv[arg + 1]);
        int rc = triton_bond_write(dev, slot, argv[arg + 2], argv[arg + 3]);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
        CFRelease(dev);
        return rc;
    } else if (arg < argc && strcmp(argv[arg], "triton-transport") == 0) {
        if (arg + 1 >= argc) {
            fprintf(stderr, "usage: %s <pidHex> [--serial S] triton-transport <slot0|slot1|slot2|rawByte>\n", argv[0]);
            IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
            CFRelease(dev);
            return 2;
        }
        int rc = triton_transport_write(dev, argv[arg + 1]);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
        CFRelease(dev);
        return rc;
    } else if (arg < argc && strcmp(argv[arg], "find") == 0) {     // probe all non-destructive opcodes for bond/serial data
        // BLOCKLIST = known state-changing/destructive opcodes; never sent here.
        static const int block[] = {0x80,0x81,0x85,0x86,0x87,0x88,0x8D,0x8E,0x8F,0x9F,
                                     0xAD,0xAF,0xB0,0xB2,0xB3,0xEB,-1};
        int rid = 2;
        for (int cmd = 0x82; cmd <= 0xFE; cmd++) {
            int blocked = 0; for (const int *b = block; *b >= 0; b++) if (*b == cmd) blocked = 1;
            if (blocked) continue;
            // send with empty payload; report only if SET succeeded (supported opcode)
            uint8_t tx[64]; memset(tx, 0, sizeof tx); tx[0] = rid; tx[1] = (uint8_t)cmd; tx[2] = 0;
            IOReturn rs = IOHIDDeviceSetReport(dev, kIOHIDReportTypeFeature, rid, tx, 64);
            if (rs != kIOReturnSuccess) continue;             // unsupported -> stall, skip silently
            usleep(15000);
            uint8_t rx[64]; memset(rx, 0, sizeof rx); rx[0] = rid; CFIndex rl = 64;
            IOReturn rg = IOHIDDeviceGetReport(dev, kIOHIDReportTypeFeature, rid, rx, &rl);
            if (rg == kIOReturnSuccess && rx[1] == cmd) {      // echoed -> real reply
                char lbl[24]; snprintf(lbl, sizeof lbl, "SUPPORTED cmd 0x%02X", cmd);
                dump(lbl, rx, (int)rl);
            }
        }
    } else if (arg < argc && strcmp(argv[arg], "labels") == 0) {   // SAFE read-only label/settings sweep
        int rid = 2;
        printf("\n##### 0x84 GET_ATTRIBUTE_LABEL idx 0..15 #####\n");
        for (int i = 0; i < 16; i++) { uint8_t p[2] = {(uint8_t)i, 0}; sc_cmd(dev, rid, 0x84, p, 2); }
        printf("\n##### 0x8A GET_SETTING_LABEL idx 0..47 #####\n");
        for (int i = 0; i < 48; i++) { uint8_t p[2] = {(uint8_t)i, 0}; sc_cmd(dev, rid, 0x8A, p, 2); }
        printf("\n##### 0x89 GET_SETTINGS_VALUES idx 0..47 #####\n");
        for (int i = 0; i < 48; i++) { uint8_t p[2] = {(uint8_t)i, 0}; sc_cmd(dev, rid, 0x89, p, 2); }
    } else if (arg < argc && strcmp(argv[arg], "seq") == 0) {
        int rc = run_seq(dev, argc, argv, arg + 1, 1);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
        CFRelease(dev);
        return rc;
    } else if (arg < argc && strcmp(argv[arg], "seq-noget") == 0) {
        int rc = run_seq(dev, argc, argv, arg + 1, 0);
        IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
        CFRelease(dev);
        return rc;
    } else if (arg + 1 < argc && strncmp(argv[arg], "rid", 3) == 0) { // custom command on one report id
        int rid = atoi(argv[arg] + 3);
        if (rid < 1 || rid > 255) { fprintf(stderr, "bad report id: %s\n", argv[arg]); return 2; }
        uint8_t cmd = (uint8_t)strtol(argv[arg + 1], NULL, 16);
        uint8_t pl[62]; int pln = 0;
        for (int i = arg + 2; i < argc && pln < 62; i++) pl[pln++] = (uint8_t)strtol(argv[i], NULL, 16);
        sc_cmd(dev, rid, cmd, pl, pln);
    } else if (arg < argc) {                   // custom single command on both command report ids
        uint8_t cmd = (uint8_t)strtol(argv[arg], NULL, 16);
        uint8_t pl[62]; int pln = 0;
        for (int i = arg + 1; i < argc && pln < 62; i++) pl[pln++] = (uint8_t)strtol(argv[i], NULL, 16);
        for (int rid = 1; rid <= 2; rid++) sc_cmd(dev, rid, cmd, pl, pln);
    } else {                                  // safe read battery on the working channel (report id 2)
        int rid = 2;
        printf("\n########## string attributes 0xAE (idx 0..15) ##########\n");
        for (int a = 0; a < 16; a++) { uint8_t aa = (uint8_t)a; sc_cmd(dev, rid, 0xAE, &aa, 1); }
        printf("\n########## 0x83 GET_ATTRIBUTES_VALUES ##########\n");
        sc_cmd(dev, rid, 0x83, NULL, 0);
        printf("\n########## 0xB4 DONGLE_GET_WIRELESS_STATE (no idx, then idx 0..3) ##########\n");
        sc_cmd(dev, rid, 0xB4, NULL, 0);
        for (int i = 0; i < 4; i++) { uint8_t ii = (uint8_t)i; sc_cmd(dev, rid, 0xB4, &ii, 1); }
        printf("\n########## 0x82 GET_DIGITAL_MAPPINGS (read) ##########\n");
        sc_cmd(dev, rid, 0x82, NULL, 0);
    }
    IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
    CFRelease(dev);
    return 0;
}