TCP is just so much easier.

Author: Monster0506

cmd/meshexec/daemon.go

@@ -1,17 +1,22 @@
 package main
 
 import (
+	"bufio"
 	"context"
+	"encoding/json"
 	"fmt"
+	"net"
 	"os"
 	"os/signal"
 	"runtime"
+	"strings"
 	"syscall"
 	"time"
 
 	core "github.com/monster0506/meshexec/internal"
 	"github.com/monster0506/meshexec/internal/agent"
 	"github.com/monster0506/meshexec/internal/config"
+	"github.com/monster0506/meshexec/internal/discovery"
 	"github.com/monster0506/meshexec/internal/executor"
 	"github.com/monster0506/meshexec/internal/mesh"
 	"github.com/monster0506/meshexec/internal/targeting"
@@ -55,9 +60,15 @@ func runDaemon(cmd *cobra.Command) error {
 		_ = os.Setenv("MESHEXEC_BLE_IMPL", "sidecar")
 	}
 
+	if logger != nil {
+		logger.Info("daemon: building mesh node", nil)
+	}
 	// Build mesh node
 	node, err := newMeshNodeForDaemon(cfg)
 	if err != nil {
+		if logger != nil {
+			logger.Error("daemon: mesh init failed", err, nil)
+		}
 		return fmt.Errorf("mesh init: %w", err)
 	}
 
@@ -76,11 +87,20 @@ func runDaemon(cmd *cobra.Command) error {
 	// Start services
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
+	if logger != nil {
+		logger.Info("daemon: starting node and agent", nil)
+	}
 	if err := node.Start(ctx); err != nil {
+		if logger != nil {
+			logger.Error("daemon: mesh start failed", err, nil)
+		}
 		return fmt.Errorf("mesh start: %w", err)
 	}
 	if err := ag.Start(ctx); err != nil {
 		_ = node.Stop()
+		if logger != nil {
+			logger.Error("daemon: agent start failed", err, nil)
+		}
 		return fmt.Errorf("agent start: %w", err)
 	}
 
@@ -99,6 +119,103 @@ func runDaemon(cmd *cobra.Command) error {
 				logger.Info("daemon: received result", map[string]interface{}{"id": m.ID, "from": m.Sender, "ttl": m.TTL})
 			}
 		}()
+		// Start simple TCP listener for POC/discovery port and mDNS advertise
+		go func(port int) {
+			addr := fmt.Sprintf(":%d", port)
+			if logger != nil {
+				logger.Info("daemon: starting tcp listener", map[string]interface{}{"addr": addr})
+			}
+			ln, err := net.Listen("tcp", addr)
+			if err != nil {
+				if logger != nil {
+					logger.Warn("tcp listen failed", map[string]interface{}{"addr": addr, "error": err.Error()})
+				}
+				return
+			}
+			if logger != nil {
+				logger.Info("daemon: tcp listener ready", map[string]interface{}{"addr": addr})
+			}
+			// mDNS advertise
+			adv, err := discovery.StartAdvertiser(cfg.Device.Name, port, map[string]string{
+				"role": cfg.Device.Role,
+				"os":   cfg.Device.OS,
+				"arch": cfg.Device.Arch,
+			})
+			if err == nil {
+				if logger != nil {
+					logger.Info("daemon: mdns advertiser started", map[string]interface{}{"name": cfg.Device.Name, "port": port})
+				}
+				go func() { <-ctx.Done(); adv.Stop() }()
+			}
+			go func() { <-ctx.Done(); _ = ln.Close() }()
+			for {
+				c, err := ln.Accept()
+				if err != nil {
+					select {
+					case <-ctx.Done():
+						return
+					default:
+					}
+					if logger != nil {
+						logger.Warn("daemon: accept error", map[string]interface{}{"error": err.Error()})
+					}
+					continue
+				}
+				go func(conn net.Conn) {
+					if logger != nil {
+						logger.Info("daemon: connection accepted", map[string]interface{}{"remote": conn.RemoteAddr().String()})
+					}
+					defer func() { _ = conn.Close() }()
+					// Read one line; support raw text or JSON {"cmd":"..."}
+					r := bufio.NewReader(conn)
+					line, _ := r.ReadString('\n')
+					if logger != nil {
+						logger.Debug("daemon: received line", map[string]interface{}{"bytes": len(line)})
+					}
+					cmdStr := ""
+					var payload struct {
+						Cmd string `json:"cmd"`
+					}
+					if json.Unmarshal([]byte(line), &payload) == nil && payload.Cmd != "" {
+						cmdStr = payload.Cmd
+					} else {
+						cmdStr = line
+					}
+					cmdStr = strings.TrimSpace(cmdStr)
+					if cmdStr == "" {
+						return
+					}
+					if logger != nil {
+						logger.Info("daemon: executing", map[string]interface{}{"cmd": cmdStr})
+					}
+					// Execute command via executor
+					ctxExec, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+					defer cancel()
+					res, err := exec.Execute(ctxExec, cmdStr)
+					if err != nil && res != nil && res.Stderr == "" {
+						res.Stderr = err.Error()
+					}
+					if res != nil && logger != nil {
+						logger.Debug("daemon: exec result", map[string]interface{}{"code": res.ExitCode, "stdout_len": len(res.Stdout), "stderr_len": len(res.Stderr)})
+					}
+					if res != nil {
+						if res.ExitCode == 0 && res.Status == "" {
+							res.Status = "success"
+						}
+						if res.ExitCode != 0 && res.Status == "" {
+							res.Status = "failed"
+						}
+					}
+					_ = json.NewEncoder(conn).Encode(map[string]interface{}{
+						"ok":     true,
+						"result": res,
+					})
+					if logger != nil {
+						logger.Info("daemon: response sent", map[string]interface{}{"remote": conn.RemoteAddr().String()})
+					}
+				}(c)
+			}
+		}(cfg.Network.TCPPort)
 	}
 
 	// Wait for termination signal (test seam)