Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
7.4 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

package cmd

import (
	"context"
	"fmt"
	"io"
	"net/mail"
	"os"
	"slices"
	"strconv"
	"strings"

	"github.com/spf13/cobra"

	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/adminapi"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/ui"
)

type emailFlags struct {
	Host         string
	Port         int
	TLS          string
	Username     string
	PasswordFile string
	From         string
}

func readSecretFile(app *App, path, flag string) (string, error) {
	var data []byte
	var err error
	if path == "-" {
		data, err = io.ReadAll(app.UI.Stdin())
	} else {
		data, err = os.ReadFile(path)
	}
	if err != nil {
		return "", ui.Failed(fmt.Sprintf("Couldn't read the file passed with --%s.", flag), "Check the path and try again.")
	}
	secret := strings.TrimRight(string(data), "\r\n")
	if secret == "" {
		return "", ui.Usage(fmt.Sprintf("The file passed with --%s is empty.", flag))
	}
	return secret, nil
}

func validHost(s string) error {
	s = strings.TrimSpace(s)
	if s == "" || strings.ContainsAny(s, " /:") {
		return ui.Usage("Pass --host as a host name, like smtp.example.com.")
	}
	return nil
}

func validFrom(s string) error {
	if _, err := mail.ParseAddress(s); err != nil {
		return ui.Usage("Pass --from as an email address, like Example Chat <[email protected]>.")
	}
	return nil
}

func validPort(s string) error {
	n, err := strconv.Atoi(strings.TrimSpace(s))
	if err != nil || n < 1 || n > 65535 {
		return ui.Usage("Pass --port as a number from 1 to 65535.")
	}
	return nil
}

const tlsUsage = "how the connection is encrypted (starttls, implicit, opportunistic or none). Picked from the port when left out"

func validTLS(mode, flag string) error {
	if mode == "" || slices.Contains(adminapi.TLSModes, mode) {
		return nil
	}
	return ui.Usage(fmt.Sprintf("Pass --%s starttls, implicit, opportunistic or none.", flag))
}

func tlsFix(message, fallback string) string {
	if certificateFailed(message) {
		return "If your email server's certificate comes from your own CA, put that CA's PEM file in the ca folder of your instance, then run rexctl config set FLUXER_NODE_EXTRA_CA_CERTS " + stack.NodeCADir + "/<file>. If it doesn't use encryption, run rexctl email set --tls none."
	}
	if adminapi.StartTLSFailed(message) {
		return "If your email server doesn't use encryption, run rexctl email set --tls none."
	}
	return fallback
}

func certificateFailed(message string) bool {
	return strings.Contains(strings.ToLower(message), "certificate")
}

func smtpReason(message string) string {
	if certificateFailed(message) {
		return "Your email server's certificate isn't trusted. It may be self-signed."
	}
	return sentenceOf(ui.Inline(message))
}

func newEmailCmd(app *App) *cobra.Command {
	c := &cobra.Command{Use: "email", Short: "Set up how your instance sends email", Args: noArgs}
	var f emailFlags
	set := &cobra.Command{Use: "set", Short: "Set the SMTP server", Args: noArgs}
	set.Flags().StringVar(&f.Host, "host", "", "the SMTP server")
	set.Flags().IntVar(&f.Port, "port", 587, "the SMTP port")
	set.Flags().StringVar(&f.TLS, "tls", "", tlsUsage)
	set.Flags().StringVar(&f.Username, "username", "", "the username for the SMTP server")
	set.Flags().StringVar(&f.PasswordFile, "password-file", "", "file with the SMTP password, or - for stdin")
	set.Flags().StringVar(&f.From, "from", "", "sender, like Example Chat <[email protected]>")
	set.RunE = func(c *cobra.Command, _ []string) error {
		if err := validTLS(f.TLS, "tls"); err != nil {
			return err
		}
		port := strconv.Itoa(f.Port)
		fields := []ui.Field{
			{Flag: "host", Title: "SMTP server", Value: &f.Host, Validate: validHost},
			{Flag: "port", Title: "Port", Value: &port, Default: "587", Validate: validPort},
		}
		if app.UI.Interactive() || c.Flags().Changed("username") {
			fields = append(fields, ui.Field{Flag: "username", Title: "SMTP username", Value: &f.Username, Optional: true})
		}
		fields = append(fields, ui.Field{Flag: "from", Title: "Send from", Value: &f.From, Validate: validFrom})
		if err := app.UI.Ask(c, fields...); err != nil {
			return err
		}
		if err := validHost(f.Host); err != nil {
			return ui.Usage(err.Error())
		}
		if err := validPort(port); err != nil {
			return ui.Usage(err.Error())
		}
		from, err := mail.ParseAddress(f.From)
		if err != nil {
			return ui.Usage("Pass --from as an email address, like Example Chat <[email protected]>.")
		}
		var password string
		if f.PasswordFile != "" {
			if password, err = readSecretFile(app, f.PasswordFile, "password-file"); err != nil {
				return err
			}
		} else if app.UI.Interactive() && f.Username != "" {
			if err := app.UI.Ask(c, ui.Field{Flag: "password-file", Title: "SMTP password", Value: &password, Secret: true}); err != nil {
				return err
			}
		}
		portNum, _ := strconv.Atoi(port)
		settings := adminapi.SMTPSettings{
			Host:     strings.TrimSpace(f.Host),
			Port:     portNum,
			TLS:      f.TLS,
			Username: f.Username,
			Password: password,
			FromName: from.Name,
			FromAddr: from.Address,
		}
		return adminWrite(c, app, func(ctx context.Context, api *adminapi.Client, _ *instance.Instance) error {
			if settings.TLS == "" {
				saved, err := api.SavedTLSMode(ctx, settings.Host, settings.Port)
				if err != nil {
					return err
				}
				settings.TLS = saved
			}
			if err := api.SetSMTP(ctx, settings); err != nil {
				return err
			}
			app.UI.OK("Saved the email settings.")
			res, err := api.TestSMTP(ctx, "")
			if err != nil {
				return err
			}
			if !res.OK {
				return ui.Failed(fmt.Sprintf("Fluxer couldn't sign in to %s. %s", settings.Host, smtpReason(res.Error)), tlsFix(res.Error, "Check the settings, then run rexctl email set again."))
			}
			app.UI.OK("Fluxer signed in to %s.", settings.Host)
			app.UI.Info("Run rexctl email test [email protected] to send a test email.")
			return nil
		})
	}

	test := &cobra.Command{Use: "test [address]", Short: "Send a test email", Args: maxArgs(1)}
	test.RunE = func(c *cobra.Command, args []string) error {
		to := ""
		if len(args) == 1 {
			to = strings.TrimSpace(args[0])
			if _, err := mail.ParseAddress(to); err != nil {
				return ui.Usage("Pass an email address, like [email protected].")
			}
		}
		return adminRead(c, app, func(ctx context.Context, api *adminapi.Client, _ *instance.Instance) error {
			res, err := api.TestSMTP(ctx, to)
			if err != nil {
				return err
			}
			if !res.OK {
				return ui.Failed(fmt.Sprintf("Fluxer couldn't send email. %s", smtpReason(res.Error)), tlsFix(res.Error, "Check the settings, then run rexctl email set."))
			}
			if to == "" {
				app.UI.OK("Fluxer signed in to your email server.")
				return nil
			}
			app.UI.OK("Sent a test email to %s.", to)
			return nil
		})
	}

	off := &cobra.Command{Use: "off", Short: "Stop sending email", Args: noArgs}
	off.RunE = func(c *cobra.Command, _ []string) error {
		return adminWrite(c, app, func(ctx context.Context, api *adminapi.Client, _ *instance.Instance) error {
			if err := api.EmailOff(ctx); err != nil {
				return err
			}
			app.UI.OK("Turned off email. Your instance won't send any email until you run rexctl email set.")
			return nil
		})
	}

	c.AddCommand(set, test, off)
	return c
}

func sentenceOf(s string) string {
	s = strings.TrimSpace(s)
	if s == "" {
		return ""
	}
	s = strings.ToUpper(s[:1]) + s[1:]
	if !strings.HasSuffix(s, ".") {
		s += "."
	}
	return s
}