Initial import

cmd/hamview-collector/main.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v3"
+
+	"git.maze.io/go/ham/protocol"
+
+	"git.maze.io/ham/hamview"
+	"git.maze.io/ham/hamview/internal/cmd"
+)
+
+var logger *logrus.Logger
+
+func init() {
+	logger = cmd.NewLogger(nil)
+}
+
+func main() {
+	cmd := &cli.Command{
+		Name:   "hamview-collector",
+		Usage:  "Collector for HAM radio protocols",
+		Action: run,
+		Before: cmd.ConfigureLogging(&logger),
+		Flags:  cmd.AllFlags("hamview-collector.yaml"),
+	}
+
+	if err := cmd.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}
+}
+
+type collectorConfig struct {
+	hamview.CollectorConfig `yaml:",inline"`
+	Broker                  hamview.BrokerConfig `yaml:"broker"`
+	Include                 []string             `yaml:"include"`
+	MeshCore                struct {
+		Group meshCoreGroupConfig `yaml:"group"`
+	} `yaml:"meshcore"`
+}
+
+func (config *collectorConfig) Includes() []string {
+	includes := config.Include
+	config.Include = nil
+	return includes
+}
+
+type meshCoreGroupConfig struct {
+	Secret map[string]string `yaml:"secret"`
+	Public []string          `yaml:"public"`
+}
+
+func run(ctx context.Context, command *cli.Command) error {
+	var config collectorConfig
+	if err := cmd.Load(logger, command.String(cmd.FlagConfig), &config); err != nil {
+		return err
+	}
+
+	collector, err := hamview.NewCollector(&config.CollectorConfig)
+	if err != nil {
+		return err
+	}
+	defer collector.Close()
+
+	broker, err := hamview.NewBroker(&config.Broker)
+	if err != nil {
+		return err
+	}
+	if err = broker.Start(); err != nil {
+		return err
+	}
+	defer broker.Close()
+
+	for _, proto := range []string{
+		protocol.APRS,
+		protocol.MeshCore,
+	} {
+		go collector.Collect(broker, proto+"/packet")
+	}
+
+	return cmd.WaitForInterrupt(logger, "collector")
+}

cmd/hamview-receiver/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v3"
+
+	"git.maze.io/ham/hamview/internal/cmd"
+)
+
+var logger *logrus.Logger
+
+func main() {
+	cmd := &cli.Command{
+		Name:  "hamview-receiver",
+		Usage: "Receiver for HAM radio protocols",
+		Action: func(context.Context, *cli.Command) error {
+			fmt.Println("boom! I say!")
+			return nil
+		},
+		Flags: cmd.AllFlags("hamview-receiver.yaml"),
+		Commands: []*cli.Command{
+			{
+				Name:   "aprsis",
+				Usage:  "Start an APRS-IS proxy",
+				Before: cmd.ConfigureLogging(&logger),
+				Action: runAPRSIS,
+			},
+			{
+				Name:   "meshcore",
+				Usage:  "Start a MeshCore receiver",
+				Before: cmd.ConfigureLogging(&logger),
+				Action: runMeshCore,
+			},
+		},
+	}
+
+	if err := cmd.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func waitForInterrupt() error {
+	return cmd.WaitForInterrupt(logger, "receiver")
+}

cmd/hamview-receiver/run_aprsis.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"context"
+
+	"github.com/urfave/cli/v3"
+
+	"git.maze.io/go/ham/protocol/aprs/aprsis"
+
+	"git.maze.io/ham/hamview"
+	"git.maze.io/ham/hamview/internal/cmd"
+)
+
+type aprsisConfig struct {
+	Broker   hamview.BrokerConfig `yaml:"broker"`
+	Receiver hamview.APRSISConfig `yaml:"receiver"`
+	Include  []string             `yaml:"include"`
+}
+
+func (config *aprsisConfig) Includes() []string {
+	includes := config.Include
+	config.Include = nil
+	return includes
+}
+
+func runAPRSIS(ctx context.Context, command *cli.Command) error {
+	var config = aprsisConfig{
+		Receiver: hamview.APRSISConfig{
+			Listen: hamview.DefaultAPRSISListen,
+			Server: hamview.DefaultAPRSISServer,
+		},
+	}
+	if err := cmd.Load(logger, command.String(cmd.FlagConfig), &config); err != nil {
+		return err
+	}
+
+	logger.Infof("receiver: starting APRS-IS proxy on tcp://%s to tcp://%s",
+		config.Receiver.Listen,
+		config.Receiver.Server)
+	proxy, err := aprsis.NewProxy(config.Receiver.Listen, config.Receiver.Server)
+	if err != nil {
+		return err
+	}
+
+	proxy.OnClient = func(callsign string, client *aprsis.ProxyClient) {
+		go receiveAPRSIS(&config.Broker, callsign, client)
+	}
+
+	return waitForInterrupt()
+}
+
+func receiveAPRSIS(config *hamview.BrokerConfig, callsign string, client *aprsis.ProxyClient) {
+	defer client.Close()
+
+	broker, err := hamview.NewBroker(config)
+	if err != nil {
+		logger.Errorf("receiver: can't setup to broker: %v", err)
+		return
+	}
+	defer broker.Close()
+
+	info := client.Info() // TODO: enrich info from config?
+
+	if err = broker.StartRadio("aprs", info); err != nil {
+		logger.Fatalf("receiver: can't start broker: %v", err)
+		return
+	}
+
+	logger.Infof("receiver: start receiving packets from station: %s", callsign)
+	for packet := range client.RawPackets() {
+		logger.Debugf("aprs packet: %#+v", packet)
+		if err := broker.PublishPacket("aprs/packet", packet); err != nil {
+			logger.Error(err)
+		}
+	}
+	logger.Info("receiver: stopped receiving packets from station: %s", callsign)
+}

cmd/hamview-receiver/run_meshcore.go

@@ -0,0 +1,79 @@
+package main
+
+import (
+	"context"
+
+	"github.com/urfave/cli/v3"
+
+	"git.maze.io/go/ham/protocol"
+	"git.maze.io/go/ham/protocol/meshcore"
+
+	"git.maze.io/ham/hamview"
+	"git.maze.io/ham/hamview/internal/cmd"
+)
+
+type meshCoreConfig struct {
+	Broker   hamview.BrokerConfig   `yaml:"broker"`
+	Receiver hamview.MeshCoreConfig `yaml:"receiver"`
+	Include  []string               `yaml:"include"`
+}
+
+func (config *meshCoreConfig) Includes() []string {
+	includes := config.Include
+	config.Include = nil
+	return includes
+}
+
+func runMeshCore(ctx context.Context, command *cli.Command) error {
+	var config meshCoreConfig
+	if err := cmd.Load(logger, command.String(cmd.FlagConfig), &config); err != nil {
+		return err
+	}
+
+	broker, err := hamview.NewBroker(&config.Broker)
+	if err != nil {
+		return err
+	}
+	defer broker.Close()
+
+	receiver, err := hamview.NewMeshCoreReceiver(&config.Receiver)
+	if err != nil {
+		return err
+	}
+	defer receiver.Close()
+
+	info := receiver.Info() // TODO: enrich info from config?
+	if err = broker.StartRadio(protocol.MeshCore, info); err != nil {
+		logger.Fatalf("receiver: can't start broker: %v", err)
+		return err
+	}
+
+	// Trace scheduler
+	//go receiver.RunTraces()
+
+	// Packet decoder
+	go func() {
+		logger.Info("receiver: start receiving packets")
+		for packet := range receiver.RawPackets() {
+			if len(packet.Raw) >= 1 {
+				var (
+					header      = packet.Raw[0]
+					version     = (header >> 6) & 0x03
+					routeType   = meshcore.RouteType(header & 0x03)
+					payloadType = meshcore.PayloadType((header >> 2) & 0x0F)
+				)
+				logger.Debugf("meshcore packet: %d %s %s: %d bytes",
+					version,
+					routeType,
+					payloadType,
+					len(packet.Raw))
+			}
+			if err = broker.PublishPacket("meshcore/packet", packet); err != nil {
+				logger.Errorf("receiver: failed to publish packet: %v", err)
+			}
+		}
+		logger.Warn("receiver: closing")
+	}()
+
+	return waitForInterrupt()
+}

cmd/hamview-server/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+	"os"
+
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v3"
+
+	"git.maze.io/ham/hamview"
+	"git.maze.io/ham/hamview/internal/cmd"
+)
+
+var logger = logrus.New()
+
+func main() {
+	cmd := &cli.Command{
+		Name:   "hamview-server",
+		Usage:  "Server for HAM radio protocols",
+		Action: run,
+		Before: cmd.ConfigureLogging(&logger),
+		Flags:  cmd.AllFlags("hamview-server.yaml"),
+	}
+
+	if err := cmd.Run(context.Background(), os.Args); err != nil {
+		logger.Fatal(err)
+	}
+}
+
+type serverConfig struct {
+	Database hamview.DatabaseConfig `yaml:"database"`
+	Broker   hamview.BrokerConfig   `yaml:"broker"`
+	Server   hamview.ServerConfig   `yaml:"server"`
+	Include  []string               `yaml:"include"`
+}
+
+func (config *serverConfig) Includes() []string {
+	includes := config.Include
+	config.Include = nil
+	return includes
+}
+
+func run(ctx context.Context, command *cli.Command) error {
+	var config serverConfig
+	if err := cmd.Load(logger, command.String(cmd.FlagConfig), &config); err != nil {
+		return err
+	}
+
+	server, err := hamview.NewServer(&config.Server, &config.Database)
+	if err != nil {
+		return err
+	}
+
+	return server.Run()
+}

cmd/import-letsmesh-nodes/main.go

@@ -0,0 +1,183 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"encoding/hex"
+	"encoding/json"
+	"os"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v3"
+
+	"git.maze.io/go/ham/protocol/meshcore"
+
+	"git.maze.io/ham/hamview"
+	"git.maze.io/ham/hamview/internal/cmd"
+
+	_ "github.com/cridenour/go-postgis" // PostGIS support
+	_ "github.com/lib/pq"               // PostgreSQL support
+)
+
+var logger = logrus.New()
+
+/*
+	{
+	      "public_key": "E119666239EE254E8E7B2937A99FE9DB7CBB58040B5D0E995B719C598CD261F6",
+	      "name": "~ Jonzy Heltec Repeater",
+	      "device_role": 2,
+	      "regions": [
+	        "OMA"
+	      ],
+	      "first_seen": "2026-01-18T04:31:21.694Z",
+	      "last_seen": "2026-02-20T10:30:16.144Z",
+	      "is_mqtt_connected": true,
+	      "decoded_payload": {
+	        "lat": 41.28516,
+	        "lon": -96.13876,
+	        "mode": "Repeater",
+	        "name": "~ Jonzy Heltec Repeater",
+	        "flags": 146,
+	        "is_valid": true,
+	        "signature": "F08599E4D7357E9276B5F78246C698BFFCF14EC83D8A70CAB6F8E63EDF3FEB5CB692A60C3072593ABE0261B164709F9E012AC526B5EF08407B3520C13719900E",
+	        "timestamp": 1771583405,
+	        "public_key": "E119666239EE254E8E7B2937A99FE9DB7CBB58040B5D0E995B719C598CD261F6"
+	      },
+	      "location": {
+	        "latitude": 41.28516,
+	        "longitude": -96.13876
+	      },
+	      "node_settings": {
+	        "show_neighbors": true,
+	        "show_adverts": true
+	      }
+	},
+*/
+type node struct {
+	PublicKey  string             `json:"public_key"`
+	Name       string             `json:"name"`
+	Type       int                `json:"device_role"`
+	FirstHeard time.Time          `json:"first_seen"`
+	LastHeard  time.Time          `json:"last_seen"`
+	Position   *meshcore.Position `json:"location"`
+	Payload    payload            `json:"decoded_payload`
+}
+
+type payload struct {
+	Timestamp int64 `json:"timestamp"`
+}
+
+func main() {
+	cmd := &cli.Command{
+		Name:   "import-letsmesh-nodes",
+		Action: run,
+		Before: cmd.ConfigureLogging(&logger),
+		Flags: append([]cli.Flag{
+			&cli.StringFlag{
+				Name:  "dump",
+				Usage: "letsmesh node json",
+				Value: "letsmeshnodes.json",
+			},
+		}, cmd.AllFlags("hamview-collector.yaml")...),
+	}
+
+	if err := cmd.Run(context.Background(), os.Args); err != nil {
+		logger.Fatal(err)
+	}
+}
+
+type collectorConfig struct {
+	hamview.CollectorConfig `yaml:",inline"`
+	Broker                  map[string]any `yaml:"broker"`
+	Meshcore                map[string]any `yaml:"meshcore"`
+	Include                 []string
+}
+
+func (config *collectorConfig) Includes() []string {
+	includes := config.Include
+	config.Include = nil
+	return includes
+}
+
+func run(ctx context.Context, command *cli.Command) error {
+	var config collectorConfig
+	if err := cmd.Load(logger, command.String(cmd.FlagConfig), &config); err != nil {
+		return err
+	}
+
+	db, err := sql.Open(config.Database.Type, config.Database.Conf)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	b, err := os.ReadFile(command.String("dump"))
+	if err != nil {
+		return err
+	}
+
+	var nodes struct {
+		Nodes []*node `json:"nodes"`
+	}
+	if err = json.Unmarshal(b, &nodes); err != nil {
+		return err
+	}
+
+	logger.Infof("found %d nodes", len(nodes.Nodes))
+	for _, node := range nodes.Nodes {
+		k, err := hex.DecodeString(node.PublicKey)
+		if err != nil {
+			logger.Warnf("node %s has incorrect public key: %v", node.Name, err)
+			continue
+		}
+		logger.Infof("node %s at %s", node.Name, node.Position)
+		var latitude, longitude *float64
+		if node.Position != nil {
+			latitude = &node.Position.Latitude
+			longitude = &node.Position.Longitude
+		}
+		if _, err = db.Exec(
+			`INSERT INTO meshcore_node (
+				node_type,
+				public_key,
+				name,
+				local_time,
+				first_heard,
+				last_heard,
+				last_latitude,
+				last_longitude
+			) VALUES (
+				$1,
+				$2,
+				$3,
+				$4,
+				$5,
+				$6,
+				$7,
+				$8
+			)
+			ON CONFLICT (public_key)
+			DO UPDATE
+				SET 
+					name = $3,
+					local_time = $4,
+					last_heard = $6,
+					last_latitude = $7,
+					last_longitude = $8
+			`,
+			node.Type,
+			k,
+			node.Name,
+			time.Unix(node.Payload.Timestamp, 0),
+			node.FirstHeard,
+			node.LastHeard,
+			latitude,
+			longitude,
+		); err != nil {
+			logger.Fatalf("node %s insert failed: %v", node.Name, err)
+		}
+	}
+
+	return nil
+}