getDeviceDetails - only CSV returns data, JSON hangs

[stephannn]

Hi,

Describe the bug
when I call the function getDeviceDetails with type JSON in PowerShell with:

$request = @{ action="getDeviceDetails"; type="json" } | ConvertTo-Json -Compress
$bytes = [System.Text.Encoding]::UTF8.GetBytes($request)
$segment = [System.ArraySegment[byte]]::new($bytes)
$ws.SendAsync($segment, [System.Net.WebSockets.WebSocketMessageType]::Text, $true, $ct).Wait()

the result hangs. However, if I change the type to CSV it works:

$request = @{ action="getDeviceDetails"; type="csv" } | ConvertTo-Json -Compress
$bytes = [System.Text.Encoding]::UTF8.GetBytes($request)
$segment = [System.ArraySegment[byte]]::new($bytes)
$ws.SendAsync($segment, [System.Net.WebSockets.WebSocketMessageType]::Text, $true, $ct).Wait()

To Reproduce
Steps to reproduce the behavior:

`$serverUrl = "wss://10.203.144.231:9443/control.ashx"
$username = "administrator"
$password = "administrator"

# Build x-meshauth header
$authHeader = [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($username)) + "," +
              [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($password))

# WebSocket client
$ws = [System.Net.WebSockets.ClientWebSocket]::new()
$ct = [System.Threading.CancellationToken]::None

# Add authentication header
$ws.Options.SetRequestHeader("x-meshauth", $authHeader)

$uri = [System.Uri]$serverUrl
$errorVar = $null
try {
    $ws.ConnectAsync($uri, $ct).Wait()
    Write-Host "Connected!"
}
catch {
    Write-Host "Error:" $_.Exception.InnerException.Message
    Write-Host "Details:" $_.Exception.InnerException.ToString()
}

#$ws.Dispose()

# Send your request first
$request = @{ action="getDeviceDetails"; type="json" } | ConvertTo-Json -Compress
$bytes = [System.Text.Encoding]::UTF8.GetBytes($request)
$segment = [System.ArraySegment[byte]]::new($bytes)
$ws.SendAsync($segment, [System.Net.WebSockets.WebSocketMessageType]::Text, $true, $ct).Wait()

# Buffer for receiving
$buffer = New-Object byte[] 8192

while ($ws.State -eq [System.Net.WebSockets.WebSocketState]::Open) {
    $segment = [System.ArraySegment[byte]]::new($buffer)
    $result = $ws.ReceiveAsync($segment, $ct).Result
    if ($result.MessageType -eq [System.Net.WebSockets.WebSocketMessageType]::Close) { break }

    $response = [System.Text.Encoding]::UTF8.GetString($buffer, 0, $result.Count)
    $json = $null
    try { $json = $response | ConvertFrom-Json } catch {}

    if ($json -eq $null) { continue }

     Write-Host "Action: " $json.action
    switch ($json.action.ToLower()) {
        'serverinfo' {
            Write-Host "Server info received:"
            $json.serverinfo | ConvertTo-Json -Compress | Write-Host
        }
        'meshes' {
            $meshesResult = @()
            foreach ($m in $json.meshes) {
                #$id = ($m._id -split '/')[2]
                $meshesResult += [pscustomobject][ordered]@{ID = ($m._id -split '/')[2]; Name = $($m.name)}
            }
            #$ws.CloseAsync([System.Net.WebSockets.WebSocketCloseStatus]::NormalClosure, "", [System.Threading.CancellationToken]::None).Wait()
            break  # exit after processing meshes
        }
        'nodes' {
            $nodesResult = @()
            foreach ($meshId in $json.nodes.PSObject.Properties.Name) {
                $nodes = $json.nodes.$meshId
                $DeviceGroupId = ($meshId -split '//')[1]
                foreach ($node in $nodes) {
                    $nodesResult += [pscustomobject][ordered]@{DeviceId = ($node._id -split '/')[2]; DeviceName = $($node.name); OS = $node.osdesc; DeviceGroupId = $DeviceGroupId}
                }
            }

            $ws.CloseAsync([System.Net.WebSockets.WebSocketCloseStatus]::NormalClosure, "", [System.Threading.CancellationToken]::None).Wait()
            break  # exit after processing meshes
        }
        'getDeviceDetails' {
            $nodesDetailResult = @()
            foreach ($detail in ($json.data | ConvertFrom-JSON)){
                $nodesDetailResult += [pscustomobject][ordered]@{DeviceId = ($detail.id -split '/')[2]; DeviceName = $($detail.name); SerialNumber = $detail.biosSerial ;OS = $detail.osdesc}
            }
            $ws.CloseAsync([System.Net.WebSockets.WebSocketCloseStatus]::NormalClosure, "", [System.Threading.CancellationToken]::None).Wait()
            break  # exit after processing meshes
        }
        'close' {
            Write-Host "Close received:"
            [System.Net.WebSockets.WebSocketMessageType]::Close
        }
        default {
            # Uncomment for debugging unknown messages
            # Write-Host "Other message: $response"
        }
    }
   
}

$nodesDetailResult`

Expected behavior
Result as from CSV

Screenshots
If applicable, add screenshots to help explain your problem.

Server Software (please complete the following information):

• OS: [e.g. Ubuntu]
• Virtualization: podman
• Version: 1.1.48

Additional context
Add any other context about the problem here.

[si458]

this is again not a meshcentral problem but a coder/programming issue with powershell
you are setting the byte count at 8192 which isnt enough. for example i have about 20 devices and the total byte count was over 20,000 !?
you need to loop over the bytes being replied to build the data first then when its finished call you return function
my powershell example below (generated with help from AI using my old example i gave you other day about its reply method)

add-type -TypeDefinition @"
using System;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

public static class Dummy {
    public static bool ReturnTrue(object sender,
        X509Certificate certificate,
        X509Chain chain,
        SslPolicyErrors sslPolicyErrors) { return true; }

    public static RemoteCertificateValidationCallback GetDelegate() {
        return new RemoteCertificateValidationCallback(Dummy.ReturnTrue);
    }
}
"@

[System.Net.ServicePointManager]::ServerCertificateValidationCallback = [dummy]::GetDelegate()

$serverUrl = "wss://meshcentral.mydomain.com/control.ashx"
$username = "~t:XXXXXXXXXXXX"
$password = "XXXXXXXXXXXX"

# Build x-meshauth header
$authHeader = [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($username)) + "," +
[System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($password))

# WebSocket client
$ws = [System.Net.WebSockets.ClientWebSocket]::new()
$ct = [System.Threading.CancellationToken]::None

# Add authentication header
$ws.Options.SetRequestHeader("x-meshauth", $authHeader)

$uri = [System.Uri]$serverUrl
try {
    $ws.ConnectAsync($uri, $ct).Wait()
    Write-Host "Connected!"
}
catch {
    Write-Host "Error:" $_.Exception.InnerException.Message
    Write-Host "Details:" $_.Exception.InnerException.ToString()
}

# Build request like the web UI does and Set action and responseid
$action = "getDeviceDetails"
$request = @{ action = $action; type = "json"; responseid = 'meshctrl' } | ConvertTo-Json -Compress
$bytes = [System.Text.Encoding]::UTF8.GetBytes($request)
$segment = [System.ArraySegment[byte]]::new($bytes)

# Send
$ws.SendAsync($segment, [System.Net.WebSockets.WebSocketMessageType]::Text, $true, $ct).Wait()


# Accumulate all bytes until EndOfMessage, then parse as JSON
$receivedBytes = @()
while ($ws.State -eq [System.Net.WebSockets.WebSocketState]::Open) {
    $buffer = New-Object byte[] 8192
    $segment = [System.ArraySegment[byte]]::new($buffer)
    $result = $ws.ReceiveAsync($segment, $ct).Result
    if ($result.Count -gt 0) {
        $receivedBytes += $buffer[0..($result.Count-1)]
    }
    if ($result.EndOfMessage) {
        $response = [System.Text.Encoding]::UTF8.GetString($receivedBytes)
        try {
            $json = $response | ConvertFrom-Json
            if ($json.action -eq $action) {
                Write-Host "Response: $response"
                break
            }
        }
        catch {
            Write-Host "Non-JSON response: $response"
        }
        $receivedBytes = @() # Reset for next message
    }
    if ($result.MessageType -eq [System.Net.WebSockets.WebSocketMessageType]::Close) {
        break
    }
}

# Close the socket
$ws.CloseAsync([System.Net.WebSockets.WebSocketCloseStatus]::NormalClosure, "Done", $ct).Wait()

the important bit to note as well is AI says 8192 bytes it quite small and should be larger and in multiples (1,2,4,8,16,32,64,128,etc...)
you can also see the main key bits are the $result.EndOfMessage to check you actually have finished getting all the data in the first place

PS: plz use github copilot with vs code (its free now) and really does help you, when u need a quick and simple fix!