1 files changed, 483 insertions, 0 deletions

diff --git a/cmd/axon/main.go b/cmd/axon/main.go
new file mode 100644
index 0000000..f7aaf63
--- /dev/null
+++ b/cmd/axon/main.go
@@ -0,0 +1,483 @@
+// axon is a CLI for publishing and querying events on an Axon relay.
+//
+// Usage:
+//
+//      axon keygen
+//      axon pub [flags] <relay-url>
+//      axon req [flags] <relay-url>
+//
+// The private key seed is read from --key or the AXON_KEY environment variable.
+// All binary values (IDs, pubkeys, signatures) are printed as lowercase hex.
+package main
+
+import (
+        "context"
+        "encoding/hex"
+        "encoding/json"
+        "flag"
+        "fmt"
+        "log"
+        "os"
+        "os/signal"
+        "strconv"
+        "strings"
+        "syscall"
+        "time"
+
+        "axon"
+        ws "axon/relay/websocket"
+
+        "github.com/vmihailenco/msgpack/v5"
+)
+
+// ── Wire protocol constants (mirrors relay/handler.go) ──────────────────────
+
+const (
+        msgTypeAuth        uint16 = 1
+        msgTypeSubscribe   uint16 = 2
+        msgTypeUnsubscribe uint16 = 3
+        msgTypePublish     uint16 = 4
+
+        msgTypeChallenge uint16 = 10
+        msgTypeEvent     uint16 = 11
+        msgTypeEose      uint16 = 12
+        msgTypeOk        uint16 = 13
+        msgTypeError     uint16 = 14
+)
+
+// ── Payload structs ──────────────────────────────────────────────────────────
+
+type challengePayload struct {
+        Nonce []byte `msgpack:"nonce"`
+}
+
+type authPayload struct {
+        PubKey []byte `msgpack:"pubkey"`
+        Sig    []byte `msgpack:"sig"`
+}
+
+type okPayload struct {
+        Message string `msgpack:"message"`
+}
+
+type errorPayload struct {
+        Code    uint16 `msgpack:"code"`
+        Message string `msgpack:"message"`
+}
+
+type publishPayload struct {
+        Event axon.Event `msgpack:"event"`
+}
+
+type subscribePayload struct {
+        SubID  string      `msgpack:"sub_id"`
+        Filter axon.Filter `msgpack:"filter"`
+}
+
+type eventPayload struct {
+        SubID string     `msgpack:"sub_id"`
+        Event axon.Event `msgpack:"event"`
+}
+
+type eosePayload struct {
+        SubID string `msgpack:"sub_id"`
+}
+
+// ── Transport helpers ────────────────────────────────────────────────────────
+
+func send(conn *ws.Conn, msgType uint16, payload interface{}) error {
+        b, err := msgpack.Marshal([]interface{}{msgType, payload})
+        if err != nil {
+                return err
+        }
+        return conn.Write(b)
+}
+
+func recv(conn *ws.Conn, ctx context.Context) (uint16, msgpack.RawMessage, error) {
+        data, err := conn.Read(ctx)
+        if err != nil {
+                return 0, nil, err
+        }
+        var arr []msgpack.RawMessage
+        if err := msgpack.Unmarshal(data, &arr); err != nil {
+                return 0, nil, fmt.Errorf("decode message: %w", err)
+        }
+        if len(arr) < 2 {
+                return 0, nil, fmt.Errorf("message too short (%d elements)", len(arr))
+        }
+        var t uint16
+        if err := msgpack.Unmarshal(arr[0], &t); err != nil {
+                return 0, nil, fmt.Errorf("decode message type: %w", err)
+        }
+        return t, arr[1], nil
+}
+
+// dial connects and performs the auth handshake. Returns an authenticated conn.
+func dial(relayURL string, kp axon.KeyPair) (*ws.Conn, error) {
+        conn, err := ws.Dial(relayURL)
+        if err != nil {
+                return nil, err
+        }
+
+        ctx := context.Background()
+
+        // Receive Challenge.
+        t, raw, err := recv(conn, ctx)
+        if err != nil {
+                conn.CloseConn()
+                return nil, fmt.Errorf("recv challenge: %w", err)
+        }
+        if t != msgTypeChallenge {
+                conn.CloseConn()
+                return nil, fmt.Errorf("expected challenge (10), got %d", t)
+        }
+        var cp challengePayload
+        if err := msgpack.Unmarshal(raw, &cp); err != nil {
+                conn.CloseConn()
+                return nil, fmt.Errorf("decode challenge: %w", err)
+        }
+
+        // Send Auth.
+        sig := axon.SignChallenge(kp, cp.Nonce, relayURL)
+        if err := send(conn, msgTypeAuth, authPayload{
+                PubKey: []byte(kp.PubKey),
+                Sig:    sig,
+        }); err != nil {
+                conn.CloseConn()
+                return nil, fmt.Errorf("send auth: %w", err)
+        }
+
+        // Receive Ok / Error.
+        t, raw, err = recv(conn, ctx)
+        if err != nil {
+                conn.CloseConn()
+                return nil, fmt.Errorf("recv auth response: %w", err)
+        }
+        switch t {
+        case msgTypeOk:
+                return conn, nil
+        case msgTypeError:
+                var ep errorPayload
+                msgpack.Unmarshal(raw, &ep)
+                conn.CloseConn()
+                return nil, fmt.Errorf("auth rejected (%d): %s", ep.Code, ep.Message)
+        default:
+                conn.CloseConn()
+                return nil, fmt.Errorf("unexpected message %d after auth", t)
+        }
+}
+
+// ── Output helpers ───────────────────────────────────────────────────────────
+
+// eventJSON is a JSON-serialisable view of an axon.Event with hex-encoded
+// binary fields and content treated as a UTF-8 string.
+type eventJSON struct {
+        ID        string     `json:"id"`
+        PubKey    string     `json:"pubkey"`
+        CreatedAt int64      `json:"created_at"`
+        Kind      uint16     `json:"kind"`
+        Content   string     `json:"content"`
+        Tags      []axon.Tag `json:"tags"`
+        Sig       string     `json:"sig"`
+}
+
+func toEventJSON(e *axon.Event) eventJSON {
+        return eventJSON{
+                ID:        hex.EncodeToString(e.ID),
+                PubKey:    hex.EncodeToString(e.PubKey),
+                CreatedAt: e.CreatedAt,
+                Kind:      e.Kind,
+                Content:   string(e.Content),
+                Tags:      e.Tags,
+                Sig:       hex.EncodeToString(e.Sig),
+        }
+}
+
+func printEvent(e *axon.Event) {
+        b, _ := json.Marshal(toEventJSON(e))
+        fmt.Println(string(b))
+}
+
+// ── Custom flag types ────────────────────────────────────────────────────────
+
+// tagFlag accumulates --tag name=value or --tag name=v1,v2 flags.
+type tagFlag []axon.Tag
+
+func (f *tagFlag) String() string { return fmt.Sprint([]axon.Tag(*f)) }
+func (f *tagFlag) Set(s string) error {
+        parts := strings.SplitN(s, "=", 2)
+        if len(parts) != 2 || parts[0] == "" {
+                return fmt.Errorf("expected name=value, got %q", s)
+        }
+        values := strings.Split(parts[1], ",")
+        *f = append(*f, axon.Tag{Name: parts[0], Values: values})
+        return nil
+}
+
+// kindFlag accumulates --kind flags as uint16.
+type kindFlag []uint16
+
+func (f *kindFlag) String() string { return fmt.Sprint([]uint16(*f)) }
+func (f *kindFlag) Set(s string) error {
+        v, err := strconv.ParseUint(s, 10, 16)
+        if err != nil {
+                return err
+        }
+        *f = append(*f, uint16(v))
+        return nil
+}
+
+// authorFlag accumulates --author hex-pubkey flags.
+type authorFlag [][]byte
+
+func (f *authorFlag) String() string { return fmt.Sprint([][]byte(*f)) }
+func (f *authorFlag) Set(s string) error {
+        b, err := hex.DecodeString(s)
+        if err != nil {
+                return fmt.Errorf("not valid hex: %w", err)
+        }
+        if len(b) != 32 {
+                return fmt.Errorf("pubkey must be 32 bytes (64 hex chars), got %d", len(b))
+        }
+        *f = append(*f, b)
+        return nil
+}
+
+// ── Key loading ──────────────────────────────────────────────────────────────
+
+func loadKey(hexSeed string) (axon.KeyPair, error) {
+        if hexSeed == "" {
+                hexSeed = os.Getenv("AXON_KEY")
+        }
+        if hexSeed == "" {
+                return axon.KeyPair{}, fmt.Errorf("no key: supply --key or set AXON_KEY")
+        }
+        seed, err := hex.DecodeString(hexSeed)
+        if err != nil {
+                return axon.KeyPair{}, fmt.Errorf("decode key: %w", err)
+        }
+        if len(seed) != 32 {
+                return axon.KeyPair{}, fmt.Errorf("key must be 32 bytes (64 hex chars), got %d", len(seed))
+        }
+        return axon.NewKeyPairFromSeed(seed), nil
+}
+
+// ── keygen ───────────────────────────────────────────────────────────────────
+
+func cmdKeygen(_ []string) {
+        kp, err := axon.NewKeyPair()
+        if err != nil {
+                log.Fatalf("keygen: %v", err)
+        }
+        fmt.Printf("private-key  %s\n", hex.EncodeToString(kp.PrivKey.Seed()))
+        fmt.Printf("public-key   %s\n", hex.EncodeToString(kp.PubKey))
+}
+
+// ── pub ──────────────────────────────────────────────────────────────────────
+
+func cmdPub(args []string) {
+        fs := flag.NewFlagSet("pub", flag.ExitOnError)
+        fs.Usage = func() {
+                fmt.Fprintln(os.Stderr, "usage: axon pub [flags] <relay-url>")
+                fmt.Fprintln(os.Stderr, "\nFlags:")
+                fs.PrintDefaults()
+        }
+        keyHex := fs.String("key", "", "private key seed (hex, 32 bytes). Falls back to AXON_KEY env var.")
+        kind := fs.Uint("kind", 1000, "event kind")
+        content := fs.String("content", "", "event content (string)")
+        var tags tagFlag
+        fs.Var(&tags, "tag", "add a tag: name=value or name=v1,v2 (repeatable)")
+        _ = fs.Parse(args)
+
+        relayURL := fs.Arg(0)
+        if relayURL == "" {
+                fs.Usage()
+                os.Exit(1)
+        }
+
+        kp, err := loadKey(*keyHex)
+        if err != nil {
+                log.Fatal(err)
+        }
+
+        event := axon.Event{
+                CreatedAt: time.Now().Unix(),
+                Kind:      uint16(*kind),
+                Content:   []byte(*content),
+                Tags:      []axon.Tag(tags),
+        }
+        if event.Tags == nil {
+                event.Tags = []axon.Tag{}
+        }
+        if err := axon.Sign(&event, kp); err != nil {
+                log.Fatalf("sign: %v", err)
+        }
+
+        conn, err := dial(relayURL, kp)
+        if err != nil {
+                log.Fatalf("connect: %v", err)
+        }
+        defer conn.CloseConn()
+
+        if err := send(conn, msgTypePublish, publishPayload{Event: event}); err != nil {
+                log.Fatalf("publish: %v", err)
+        }
+
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+        defer cancel()
+
+        t, raw, err := recv(conn, ctx)
+        if err != nil {
+                log.Fatalf("recv: %v", err)
+        }
+        switch t {
+        case msgTypeOk:
+                fmt.Printf("published %s\n", hex.EncodeToString(event.ID))
+        case msgTypeError:
+                var ep errorPayload
+                msgpack.Unmarshal(raw, &ep)
+                log.Fatalf("error %d: %s", ep.Code, ep.Message)
+        default:
+                log.Fatalf("unexpected message type %d", t)
+        }
+}
+
+// ── req ──────────────────────────────────────────────────────────────────────
+
+func cmdReq(args []string) {
+        fs := flag.NewFlagSet("req", flag.ExitOnError)
+        fs.Usage = func() {
+                fmt.Fprintln(os.Stderr, "usage: axon req [flags] <relay-url>")
+                fmt.Fprintln(os.Stderr, "\nPrints one JSON event per line. Exits after EOSE unless --stream is set.")
+                fmt.Fprintln(os.Stderr, "\nFlags:")
+                fs.PrintDefaults()
+        }
+        keyHex := fs.String("key", "", "private key seed (hex). Falls back to AXON_KEY env var.")
+        var kinds kindFlag
+        fs.Var(&kinds, "kind", "filter by event kind (repeatable)")
+        var authors authorFlag
+        fs.Var(&authors, "author", "filter by author pubkey hex (repeatable)")
+        var filterTags tagFlag
+        fs.Var(&filterTags, "tag", "filter by tag: name=value (repeatable)")
+        since := fs.Int64("since", 0, "only events with created_at >= this unix timestamp")
+        until := fs.Int64("until", 0, "only events with created_at <= this unix timestamp")
+        limit := fs.Int("limit", 0, "max events to return (0 = no limit)")
+        stream := fs.Bool("stream", false, "keep streaming live events after EOSE (Ctrl-C to exit)")
+        _ = fs.Parse(args)
+
+        relayURL := fs.Arg(0)
+        if relayURL == "" {
+                fs.Usage()
+                os.Exit(1)
+        }
+
+        kp, err := loadKey(*keyHex)
+        if err != nil {
+                log.Fatal(err)
+        }
+
+        filter := axon.Filter{
+                Kinds:   []uint16(kinds),
+                Authors: [][]byte(authors),
+                Since:   *since,
+                Until:   *until,
+                Limit:   int32(*limit),
+        }
+        for _, t := range filterTags {
+                filter.Tags = append(filter.Tags, axon.TagFilter{Name: t.Name, Values: t.Values})
+        }
+
+        conn, err := dial(relayURL, kp)
+        if err != nil {
+                log.Fatalf("connect: %v", err)
+        }
+        defer conn.CloseConn()
+
+        subID := "req-" + strconv.FormatInt(time.Now().UnixNano(), 36)
+        if err := send(conn, msgTypeSubscribe, subscribePayload{SubID: subID, Filter: filter}); err != nil {
+                log.Fatalf("subscribe: %v", err)
+        }
+
+        ctx, cancel := context.WithCancel(context.Background())
+        defer cancel()
+
+        // Cancel on Ctrl-C when streaming.
+        if *stream {
+                sigCh := make(chan os.Signal, 1)
+                signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+                go func() {
+                        <-sigCh
+                        cancel()
+                }()
+        }
+
+        for {
+                t, raw, err := recv(conn, ctx)
+                if err != nil {
+                        if ctx.Err() != nil {
+                                return // clean cancellation
+                        }
+                        log.Fatalf("recv: %v", err)
+                }
+                switch t {
+                case msgTypeEvent:
+                        var ep eventPayload
+                        if err := msgpack.Unmarshal(raw, &ep); err != nil {
+                                log.Printf("decode event: %v", err)
+                                continue
+                        }
+                        printEvent(&ep.Event)
+
+                case msgTypeEose:
+                        if !*stream {
+                                return
+                        }
+                        // Keep looping for live events.
+
+                case msgTypeError:
+                        var ep errorPayload
+                        msgpack.Unmarshal(raw, &ep)
+                        log.Fatalf("error %d: %s", ep.Code, ep.Message)
+
+                default:
+                        log.Printf("unexpected message type %d", t)
+                }
+        }
+}
+
+// ── main ─────────────────────────────────────────────────────────────────────
+
+func usage() {
+        fmt.Fprintln(os.Stderr, "usage: axon <command> [flags]")
+        fmt.Fprintln(os.Stderr, "")
+        fmt.Fprintln(os.Stderr, "Commands:")
+        fmt.Fprintln(os.Stderr, "  keygen   Generate a new Ed25519 keypair")
+        fmt.Fprintln(os.Stderr, "  pub      Publish an event to a relay")
+        fmt.Fprintln(os.Stderr, "  req      Query or stream events from a relay")
+        fmt.Fprintln(os.Stderr, "")
+        fmt.Fprintln(os.Stderr, "Run 'axon <command> -h' for command-specific help.")
+}
+
+func main() {
+        log.SetFlags(0)
+        log.SetPrefix("axon: ")
+
+        if len(os.Args) < 2 {
+                usage()
+                os.Exit(1)
+        }
+
+        cmd, rest := os.Args[1], os.Args[2:]
+        switch cmd {
+        case "keygen":
+                cmdKeygen(rest)
+        case "pub":
+                cmdPub(rest)
+        case "req":
+                cmdReq(rest)
+        default:
+                fmt.Fprintf(os.Stderr, "axon: unknown command %q\n\n", cmd)
+                usage()
+                os.Exit(1)
+        }
+}