Try to fix showing output for commands, idk if this will work.

Author: Monster0506

cmd/meshexec/daemon.go

@@ -86,6 +86,19 @@ func runDaemon(cmd *cobra.Command) error {
 
 	if logger != nil {
 		logger.Info("daemon started", map[string]interface{}{"device": cfg.Device.Name})
+		// Add subscriptions to log inbound command/result messages for observability
+		cmdCh := node.Subscribe(core.MessageTypeCommand)
+		resCh := node.Subscribe(core.MessageTypeResult)
+		go func() {
+			for m := range cmdCh {
+				logger.Info("daemon: received command", map[string]interface{}{"id": m.ID, "from": m.Sender, "ttl": m.TTL, "cmd": m.Command})
+			}
+		}()
+		go func() {
+			for m := range resCh {
+				logger.Info("daemon: received result", map[string]interface{}{"id": m.ID, "from": m.Sender, "ttl": m.TTL})
+			}
+		}()
 	}
 
 	// Wait for termination signal (test seam)

cmd/meshexec/run.go

@@ -215,7 +215,30 @@ var runCmd = &cobra.Command{
 		select {
 		case rm := <-resCh:
 			if rm != nil {
-				fmt.Printf("Received a result message (id=%s, sender=%s)\n", rm.ID, rm.Sender)
+				// If payload contains the raw JSON, try to deserialize ResultMessage for rich output
+				printed := false
+				if len(rm.Payload) > 0 {
+					var full messages.MessageHandler
+					// Use handler to deserialize based on embedded type
+					if v, err := full.DeserializeMessage(rm.Payload); err == nil {
+						if res, ok := v.(*core.ResultMessage); ok {
+							r := res.Result
+							fmt.Printf("Result: status=%s code=%d device=%s\n", r.Status, r.ExitCode, r.Device)
+							if s := strings.TrimSpace(r.Stdout); s != "" {
+								fmt.Println("stdout:")
+								fmt.Println(s)
+							}
+							if s := strings.TrimSpace(r.Stderr); s != "" {
+								fmt.Println("stderr:")
+								fmt.Println(s)
+							}
+							printed = true
+						}
+					}
+				}
+				if !printed {
+					fmt.Printf("Received a result message (id=%s, sender=%s)\n", rm.ID, rm.Sender)
+				}
 			} else {
 				fmt.Println("Result channel closed without message")
 			}

cmd/meshexec/smoke.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"runtime"
+	"strings"
 	"time"
 
 	core "github.com/monster0506/meshexec/internal"
@@ -131,10 +132,29 @@ var smokeCmd = &cobra.Command{
 			os.Exit(6)
 		}
 
-		// Print result summary
-		fmt.Printf("Result received: id=%s type=%s sender=%s ttl=%d\n", got.ID, got.Type, got.Sender, got.TTL)
-		// In this smoke path, stdout/stderr/exitcode are carried inside ResultMessage payload (handled by higher layers),
-		// but MeshMessage schema does not include them; we just confirm receipt.
+		// Print rich result if payload contains a serialized ResultMessage
+		printed := false
+		if len(got.Payload) > 0 {
+			mh := messages.NewMessageHandlerWithLevel(logLevel)
+			if v, err := mh.DeserializeMessage(got.Payload); err == nil {
+				if res, ok := v.(*core.ResultMessage); ok {
+					r := res.Result
+					fmt.Printf("Result: status=%s code=%d device=%s\n", r.Status, r.ExitCode, r.Device)
+					if s := strings.TrimSpace(r.Stdout); s != "" {
+						fmt.Println("stdout:")
+						fmt.Println(s)
+					}
+					if s := strings.TrimSpace(r.Stderr); s != "" {
+						fmt.Println("stderr:")
+						fmt.Println(s)
+					}
+					printed = true
+				}
+			}
+		}
+		if !printed {
+			fmt.Printf("Result received: id=%s type=%s sender=%s ttl=%d\n", got.ID, got.Type, got.Sender, got.TTL)
+		}
 
 		// Cleanup
 		_ = ag.Stop()

internal/agent/agent.go

@@ -2,6 +2,7 @@ package agent
 
 import (
 	"context"
+	"strings"
 	"sync"
 	"time"
 
@@ -119,7 +120,7 @@ func (a *Agent) ProcessCommand(msg *core.MeshMessage) error {
 	var execRes *core.ExecutionResult
 	var execErr error
 	if a.exec != nil {
-		cmdLine := buildCommandLine(msg.Command, msg.Payload)
+		cmdLine := commandLineFromMessage(msg)
 		if err := a.exec.ValidateCommand(cmdLine); err != nil {
 			return err
 		}
@@ -145,7 +146,16 @@ func (a *Agent) ProcessCommand(msg *core.MeshMessage) error {
 			}
 		}
 	}
+	// Ensure required fields are populated for downstream validation/printing
 	execRes.Device = a.device.Name
+	if execRes.ID == "" {
+		mhTmp := messages.NewMessageHandlerWithLevel("none")
+		gen := mhTmp.CreateExecutionResult(msg.Command, execRes.Status, execRes.Stdout, execRes.Stderr, execRes.ExitCode, execRes.Device, time.Duration(execRes.Duration)*time.Millisecond)
+		execRes.ID = gen.ID
+		if execRes.Type == "" {
+			execRes.Type = gen.Type
+		}
+	}
 
 	// Create and sign result
 	mh := messages.NewMessageHandlerWithLevel("none")
@@ -170,13 +180,26 @@ func (a *Agent) ValidateCommand(msg *core.MeshMessage) error {
 	if a.exec == nil {
 		return nil
 	}
-	cmdLine := buildCommandLine(msg.Command, msg.Payload)
+	cmdLine := commandLineFromMessage(msg)
 	return a.exec.ValidateCommand(cmdLine)
 }
 
-func buildCommandLine(command string, payload []byte) string {
-	if command == "" {
+// commandLineFromMessage reconstructs the intended command line from a possibly down-cast MeshMessage.
+// If the raw JSON payload is present and represents a CommandMessage, we include arguments.
+func commandLineFromMessage(msg *core.MeshMessage) string {
+	if msg == nil {
 		return ""
 	}
-	return command
+	if len(msg.Payload) > 0 {
+		mh := messages.NewMessageHandlerWithLevel("none")
+		if v, err := mh.DeserializeMessage(msg.Payload); err == nil {
+			if cm, ok := v.(*core.CommandMessage); ok {
+				if len(cm.Arguments) > 0 {
+					return cm.Command + " " + strings.Join(cm.Arguments, " ")
+				}
+				return cm.Command
+			}
+		}
+	}
+	return msg.Command
 }

internal/ble/transport_sidecar_windows.go

@@ -118,9 +118,8 @@ func (t *SidecarTransport) Advertise(ctx context.Context, serviceData []byte) er
 	if t.logger != nil {
 		t.logger.Info("Sidecar: starting advertise", map[string]interface{}{"len": len(serviceData)})
 	}
-	cfg := core.DefaultConfig()
 	params := map[string]interface{}{
-		"service_uuid":     cfg.Network.ServiceUUID,
+		"service_uuid":     t.serviceUUID,
 		"local_name":       "meshexec",
 		"service_data_b64": base64.StdEncoding.EncodeToString(serviceData),
 	}
@@ -154,16 +153,15 @@ func (t *SidecarTransport) CreateGATTService() (*core.GATTService, error) {
 	if t.logger != nil {
 		t.logger.Info("Sidecar: creating GATT service", nil)
 	}
-	cfg := core.DefaultConfig()
 	params := map[string]interface{}{
-		"service_uuid":        cfg.Network.ServiceUUID,
-		"characteristic_uuid": cfg.Network.CharacteristicUUID,
+		"service_uuid":        t.serviceUUID,
+		"characteristic_uuid": t.charUUID,
 		"properties":          "read,write,notify",
 	}
 	if _, err := t.do("gatt_create", params); err != nil {
 		return nil, err
 	}
-	return &core.GATTService{UUID: cfg.Network.ServiceUUID, Characteristics: []core.GATTCharacteristic{{UUID: cfg.Network.CharacteristicUUID, Writable: true}}}, nil
+	return &core.GATTService{UUID: t.serviceUUID, Characteristics: []core.GATTCharacteristic{{UUID: t.charUUID, Writable: true}}}, nil
 }
 
 // SubscribeWriteNotifications subscribes to incoming GATT write events from sidecar and streams payloads.
@@ -285,7 +283,7 @@ func (t *SidecarTransport) CentralBroadcast(ctx context.Context, data []byte) er
 		"service_uuid":        t.serviceUUID,
 		"characteristic_uuid": t.charUUID,
 		"value_b64":           base64.StdEncoding.EncodeToString(data),
-		"scan_ms":             800,
+		"scan_ms":             2000,
 	}
 	// Best-effort: make a short-lived request; sidecar performs scan/connect/write internally
 	if _, err := t.do("central_broadcast", p); err != nil {

internal/mesh/node.go

@@ -133,6 +133,8 @@ func (n *Node) Start(ctx context.Context) error {
 						if full := n.tryReassemble(b); full != nil {
 							var m core.MeshMessage
 							if err := json.Unmarshal(full, &m); err == nil {
+								// Preserve raw JSON payload so subscribers can deserialize full message (e.g., results)
+								m.Payload = append([]byte(nil), full...)
 								n.publishLocal(&m)
 							}
 						}

internal/messages/messages.go

@@ -54,6 +54,17 @@ func (h *MessageHandler) CreateCommandMessage(
 		Timeout:   timeout,
 	}
 
+	// Embed a raw JSON representation (without payload) for local delivery convenience
+	// to allow receivers to deserialize the full typed message from MeshMessage.Payload.
+	// Avoid recursion by marshaling a copy with empty payload.
+	{
+		tmp := *msg
+		tmp.Payload = nil
+		if b, err := json.Marshal(&tmp); err == nil {
+			msg.Payload = b
+		}
+	}
+
 	h.logger.Debug("Created command message", map[string]interface{}{
 		"message_id": msg.ID,
 		"command":    command,
@@ -83,6 +94,14 @@ func (h *MessageHandler) CreateResultMessage(
 		CommandID: commandID,
 		Result:    result,
 	}
+	// Embed raw JSON (without payload) for local delivery convenience
+	{
+		tmp := *msg
+		tmp.Payload = nil
+		if b, err := json.Marshal(&tmp); err == nil {
+			msg.Payload = b
+		}
+	}
 	return msg
 }
 

sidecar/WinBLE/Program.cs

@@ -282,7 +282,7 @@ async Task<JsonElement> HandleAsync(JsonElement req)
                     {
                         var req2 = await e.GetRequestAsync();
                         var len = req2.Value?.Length ?? 0;
-                        Log("DEBUG", "gatt write request", new Dictionary<string, object?> { { "len", len } });
+                        Log("INFO", "gatt write request", new Dictionary<string, object?> { { "len", len }, { "session", e.Session.SessionId } });
                         if (req2.Value != null)
                         {
                             var bytes = new byte[req2.Value.Length];
@@ -341,6 +341,7 @@ async Task<JsonElement> HandleAsync(JsonElement req)
                     try
                     {
                         if (!e.Advertisement.ServiceUuids.Contains(svc)) return;
+                        Log("INFO", "central match", new Dictionary<string, object?> { { "addr", e.BluetoothAddress }, { "rssi", e.RawSignalStrengthInDBm } });
                         var dev = await BluetoothLEDevice.FromBluetoothAddressAsync(e.BluetoothAddress);
                         if (dev == null) return;
                         var result = await dev.GetGattServicesForUuidAsync(svc);
@@ -369,9 +370,11 @@ async Task<JsonElement> HandleAsync(JsonElement req)
                         Log("ERROR", "central write failed", new Dictionary<string, object?> { { "error", ex.Message } });
                     }
                 };
+                Log("INFO", "central_broadcast start", new Dictionary<string, object?> { { "scan_ms", scanMs } });
                 watcher.Start();
                 await Task.Delay(scanMs);
                 watcher.Stop();
+                Log("INFO", "central_broadcast stop", null);
                 return JsonDocument.Parse("{\"ok\":true}").RootElement;
             }
         // gatt_subscribe / gatt_unsubscribe are handled in ServeAsync where writer is in scope

sidecar/WinBLE/packages.lock.json

@@ -1,14 +1,6 @@
 {
   "version": 1,
   "dependencies": {
-    "net8.0-windows10.0.19041": {
-      "Microsoft.NET.ILLink.Tasks": {
-        "type": "Direct",
-        "requested": "[8.0.19, )",
-        "resolved": "8.0.19",
-        "contentHash": "IhHf+zeZiaE5EXRyxILd4qM+Hj9cxV3sa8MpzZgeEhpvaG3a1VEGF6UCaPFLO44Kua3JkLKluE0SWVamS50PlA=="
-      }
-    },
-    "net8.0-windows10.0.19041/win-x64": {}
+    "net8.0-windows10.0.19041": {}
   }
 }