much more colors everywhere and everything is prettier.

event.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/fatih/color"
 	"github.com/mailru/easyjson"
 	"github.com/nbd-wtf/go-nostr"
 	"github.com/nbd-wtf/go-nostr/nip13"
@@ -133,8 +134,17 @@ example:
 	Action: func(ctx context.Context, c *cli.Command) error {
 		// try to connect to the relays here
 		var relays []*nostr.Relay
+
+		// these are defaults, they will be replaced if we use the magic dynamic thing
+		logthis := func(relayUrl string, s string, args ...any) { log(s, args...) }
+		colorizethis := func(relayUrl string, colorize func(string, ...any) string) {}
+
 		if relayUrls := c.Args().Slice(); len(relayUrls) > 0 {
-			relays = connectToAllRelays(ctx, relayUrls, nil)
+			relays = connectToAllRelays(ctx, c, relayUrls, nil,
+				nostr.WithAuthHandler(func(ctx context.Context, authEvent nostr.RelayEvent) error {
+					return authSigner(ctx, c, func(s string, args ...any) {}, authEvent)
+				}),
+			)
 			if len(relays) == 0 {
 				log("failed to connect to any of the given relays.\n")
 				os.Exit(3)
@@ -301,37 +311,104 @@ example:
 			successRelays := make([]string, 0, len(relays))
 			if len(relays) > 0 {
 				os.Stdout.Sync()
-				for _, relay := range relays {
-				publish:
-					log("publishing to %s... ", relay.URL)
+
+				if supportsDynamicMultilineMagic() {
+					// overcomplicated multiline rendering magic
 					ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 					defer cancel()
 
-					err := relay.Publish(ctx, evt)
-					if err == nil {
-						// published fine
-						log("success.\n")
-						successRelays = append(successRelays, relay.URL)
-						continue // continue to next relay
-					}
-
-					// error publishing
-					if strings.HasPrefix(err.Error(), "msg: auth-required:") && kr != nil && doAuth {
-						// if the relay is requesting auth and we can auth, let's do it
-						pk, _ := kr.GetPublicKey(ctx)
-						log("performing auth as %s... ", pk)
-						if err := relay.Auth(ctx, func(authEvent *nostr.Event) error {
-							return kr.SignEvent(ctx, authEvent)
-						}); err == nil {
-							// try to publish again, but this time don't try to auth again
-							doAuth = false
-							goto publish
-						} else {
-							log("auth error: %s. ", err)
+					urls := make([]string, len(relays))
+					lines := make([][][]byte, len(urls))
+					flush := func() {
+						for _, line := range lines {
+							for _, part := range line {
+								os.Stderr.Write(part)
+							}
+							os.Stderr.Write([]byte{'\n'})
 						}
 					}
-					log("failed: %s\n", err)
+					render := func() {
+						clearLines(len(lines))
+						flush()
+					}
+					flush()
+
+					logthis = func(relayUrl, s string, args ...any) {
+						idx := slices.Index(urls, relayUrl)
+						lines[idx] = append(lines[idx], []byte(fmt.Sprintf(s, args...)))
+						render()
+					}
+					colorizethis = func(relayUrl string, colorize func(string, ...any) string) {
+						cleanUrl, _ := strings.CutPrefix(relayUrl, "wss://")
+						idx := slices.Index(urls, relayUrl)
+						lines[idx][0] = []byte(fmt.Sprintf("publishing to %s... ", colorize(cleanUrl)))
+						render()
+					}
+
+					for i, relay := range relays {
+						urls[i] = relay.URL
+						lines[i] = make([][]byte, 1, 3)
+						colorizethis(relay.URL, color.CyanString)
+					}
+					render()
+
+					for res := range sys.Pool.PublishMany(ctx, urls, evt) {
+						if res.Error == nil {
+							colorizethis(res.RelayURL, colors.successf)
+							logthis(res.RelayURL, "success.")
+							successRelays = append(successRelays, res.RelayURL)
+						} else {
+							colorizethis(res.RelayURL, colors.errorf)
+
+							// in this case it's likely that the lowest-level error is the one that will be more helpful
+							low := unwrapAll(res.Error)
+
+							// hack for some messages such as from relay.westernbtc.com
+							msg := strings.ReplaceAll(low.Error(), evt.PubKey, "author")
+
+							// do not allow the message to overflow the term window
+							msg = clampMessage(msg, 20+len(res.RelayURL))
+
+							logthis(res.RelayURL, msg)
+						}
+					}
+				} else {
+					// normal dumb flow
+					for _, relay := range relays {
+					publish:
+						cleanUrl, _ := strings.CutPrefix(relay.URL, "wss://")
+						log("publishing to %s... ", color.CyanString(cleanUrl))
+						ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+						defer cancel()
+
+						err := relay.Publish(ctx, evt)
+						if err == nil {
+							// published fine
+							log("success.\n")
+							successRelays = append(successRelays, relay.URL)
+							continue // continue to next relay
+						}
+
+						// error publishing
+						if strings.HasPrefix(err.Error(), "msg: auth-required:") && kr != nil && doAuth {
+							// if the relay is requesting auth and we can auth, let's do it
+							pk, _ := kr.GetPublicKey(ctx)
+							npub, _ := nip19.EncodePublicKey(pk)
+							log("authenticating as %s... ", color.YellowString("%s…%s", npub[0:7], npub[58:]))
+							if err := relay.Auth(ctx, func(authEvent *nostr.Event) error {
+								return kr.SignEvent(ctx, authEvent)
+							}); err == nil {
+								// try to publish again, but this time don't try to auth again
+								doAuth = false
+								goto publish
+							} else {
+								log("auth error: %s. ", err)
+							}
+						}
+						log("failed: %s\n", err)
+					}
 				}
+
 				if len(successRelays) > 0 && c.Bool("nevent") {
 					nevent, _ := nip19.EncodeEvent(evt.ID, successRelays, evt.PubKey)
 					log(nevent + "\n")