ricochet-go/ricochet-cli/ui.go

548 lines
14 KiB
Go

package main
import (
"errors"
"fmt"
"github.com/chzyer/readline"
"github.com/ricochet-im/ricochet-go/core"
"github.com/ricochet-im/ricochet-go/rpc"
"golang.org/x/net/context"
"io"
"strings"
"time"
)
const (
MinContactPrefix = 3
)
var Ui UI
type UI struct {
Input *readline.Instance
Stdout io.Writer
Client *Client
CurrentContact *Contact
commandMode bool
baseConfig *readline.Config
baseChatConfig *readline.Config
}
func (ui *UI) CommandLoop() {
ui.setupInputConfigs()
ui.Input.SetConfig(ui.baseConfig)
for {
line, err := ui.Input.Readline()
if err != nil {
return
}
if err := ui.Execute(line); err != nil {
return
}
}
}
func (ui *UI) setupInputConfigs() {
ui.baseConfig = ui.Input.Config.Clone()
ui.baseConfig.Prompt = "> "
ui.baseChatConfig = ui.baseConfig.Clone()
ui.baseChatConfig.Prompt = "\x1b[90m%s\x1b[39m | %s \x1b[34m<<\x1b[39m "
ui.baseChatConfig.UniqueEditLine = true
}
func (ui *UI) Execute(line string) error {
// Block client event handlers for threadsafety
ui.Client.Block()
defer ui.Client.Unblock()
if ui.CurrentContact != nil && !ui.commandMode {
ui.CurrentContact.Conversation.SendMessage(line)
return nil
}
words := strings.SplitN(line, " ", 2)
switch words[0] {
case "clear":
readline.ClearScreen(readline.Stdout)
case "quit":
return errors.New("Quitting")
case "status":
ui.PrintStatus()
case "connect":
status, err := ui.Client.Backend.StartNetwork(context.Background(), &ricochet.StartNetworkRequest{})
if err != nil {
fmt.Fprintf(ui.Stdout, "start network error: %v\n", err)
} else {
fmt.Fprintf(ui.Stdout, "network started: %v\n", status)
}
case "disconnect":
status, err := ui.Client.Backend.StopNetwork(context.Background(), &ricochet.StopNetworkRequest{})
if err != nil {
fmt.Fprintf(ui.Stdout, "stop network error: %v\n", err)
} else {
fmt.Fprintf(ui.Stdout, "network stopped: %v\n", status)
}
case "contacts":
ui.ListContacts()
case "add-contact":
ui.AddContact(words[1:])
case "delete-contact":
ui.DeleteContact(words[1:])
case "log":
fmt.Fprint(ui.Stdout, LogBuffer.String())
case "close":
ui.SetCurrentContact(nil)
case "help":
ui.printHelp()
default:
contact, request := ui.EntityByPrefix(line)
if contact != nil {
ui.SetCurrentContact(contact)
} else if request != nil {
ui.ShowContactRequest(request)
} else {
ui.printHelp()
}
}
return nil
}
func (ui *UI) printHelp() {
fmt.Fprintf(ui.Stdout, "Commands: clear, quit, status, connect, disconnect, contacts, add-contact, delete-contact, log, close, help\n")
}
func (ui *UI) PrintStatus() {
controlStatus := ui.Client.NetworkControlStatus()
connectionStatus := ui.Client.NetworkConnectionStatus()
switch controlStatus.Status {
case ricochet.TorControlStatus_STOPPED:
fmt.Fprintf(ui.Stdout, "Network is stopped -- type 'connect' to go online\n")
case ricochet.TorControlStatus_ERROR:
fmt.Fprintf(ui.Stdout, "Network error: %s\n", controlStatus.ErrorMessage)
case ricochet.TorControlStatus_CONNECTING:
fmt.Fprintf(ui.Stdout, "Network connecting...\n")
case ricochet.TorControlStatus_CONNECTED:
switch connectionStatus.Status {
case ricochet.TorConnectionStatus_UNKNOWN:
fallthrough
case ricochet.TorConnectionStatus_OFFLINE:
fmt.Fprintf(ui.Stdout, "Network is offline\n")
case ricochet.TorConnectionStatus_BOOTSTRAPPING:
fmt.Fprintf(ui.Stdout, "Network bootstrapping: %s\n", connectionStatus.BootstrapProgress)
case ricochet.TorConnectionStatus_READY:
fmt.Fprintf(ui.Stdout, "Network is online\n")
}
}
fmt.Fprintf(ui.Stdout, "Your ricochet ID is %s\n", ui.Client.Identity.Address)
var nContacts, nOnline int
for _, contact := range ui.Client.Contacts.Contacts {
nContacts++
if contact.Data.Status == ricochet.Contact_ONLINE {
nOnline++
}
}
if nContacts > 0 {
fmt.Fprintf(ui.Stdout, "%d of %d contacts are online\n", nOnline, nContacts)
} else {
fmt.Fprintf(ui.Stdout, "You have no contacts :(\n")
}
if reqs := len(ui.Client.Contacts.Requests); reqs > 0 {
plural := ""
if reqs > 1 {
plural = "s"
}
fmt.Fprintf(ui.Stdout, "%d new contact request%s are waiting\n", reqs, plural)
}
}
func (ui *UI) ListContacts() {
byStatus := make(map[ricochet.Contact_Status][]*Contact)
for _, contact := range ui.Client.Contacts.Contacts {
byStatus[contact.Data.Status] = append(byStatus[contact.Data.Status], contact)
}
order := []ricochet.Contact_Status{ricochet.Contact_ONLINE, ricochet.Contact_UNKNOWN, ricochet.Contact_OFFLINE, ricochet.Contact_REQUEST, ricochet.Contact_REJECTED}
for _, status := range order {
contacts := byStatus[status]
if len(contacts) == 0 {
continue
}
fmt.Fprintf(ui.Stdout, "%s\n", ColoredContactStatus(status))
for _, contact := range contacts {
unreadCount := contact.Conversation.UnreadCount()
if unreadCount > 0 {
fmt.Fprintf(ui.Stdout, " \x1b[1m%s\x1b[0m (\x1b[1m%s\x1b[0m) -- \x1b[34;1m%d new messages\x1b[0m\n", contact.Data.Nickname, ui.PrefixForAddress(contact.Data.Address), unreadCount)
} else {
fmt.Fprintf(ui.Stdout, " %s (\x1b[1m%s\x1b[0m)\n", contact.Data.Nickname, ui.PrefixForAddress(contact.Data.Address))
}
}
}
if len(ui.Client.Contacts.Requests) > 0 {
fmt.Fprintf(ui.Stdout, "\x1b[contact requests received\x1b[39m\n")
for _, request := range ui.Client.Contacts.Requests {
fmt.Fprintf(ui.Stdout, " %s (\x1b[1m%s\x1b[0m)\n", request.Address, ui.PrefixForAddress(request.Address))
}
}
}
func (ui *UI) AddContact(params []string) {
var address string
if len(params) > 0 {
address = params[0]
} else {
str, err := readline.Line("Contact address: ")
if err != nil {
return
}
address = str
}
// XXX validate address
nickname, err := readline.Line("Nickname: ")
if err != nil {
return
}
fromNickname, err := readline.Line("From (your nickname): ")
if err != nil {
return
}
message, err := readline.Line("Message: ")
if err != nil {
return
}
contact, err := ui.Client.Backend.AddContactRequest(context.Background(),
&ricochet.ContactRequest{
Direction: ricochet.ContactRequest_OUTBOUND,
Address: address,
Nickname: nickname,
Text: message,
FromNickname: fromNickname,
})
if err != nil {
fmt.Fprintf(ui.Stdout, "Failed: %s\n", err)
return
}
fmt.Fprintf(ui.Stdout, "Added contact \x1b[1m%s\x1b[0m (\x1b[1m%s\x1b[0m)\n", contact.Nickname, contact.Address)
}
func (ui *UI) DeleteContact(params []string) {
if len(params) < 1 {
fmt.Fprintf(ui.Stdout, "Usage: delete-contact [address]\n")
return
}
contact := ui.Client.Contacts.ByAddress(params[0])
if contact == nil {
contact, _ = ui.EntityByPrefix(params[0])
}
if contact == nil {
fmt.Fprintf(ui.Stdout, "No contact with address %s\n", params[0])
return
}
fmt.Fprintf(ui.Stdout, "\nThis contact will be \x1b[31mdeleted\x1b[0m:\n\n")
fmt.Fprintf(ui.Stdout, " Address:\t%s\n", contact.Data.Address)
fmt.Fprintf(ui.Stdout, " Name:\t%s\n", contact.Data.Nickname)
fmt.Fprintf(ui.Stdout, " Online:\t%s\n", contact.Data.LastConnected)
fmt.Fprintf(ui.Stdout, " Created:\t%s\n\n", contact.Data.WhenCreated)
confirm, err := readline.Line("Type YES to confirm: ")
if err != nil || confirm != "YES" {
fmt.Fprintf(ui.Stdout, "Aborted\n")
return
}
_, err = ui.Client.Backend.DeleteContact(context.Background(),
&ricochet.DeleteContactRequest{Address: contact.Data.Address})
if err != nil {
fmt.Fprintf(ui.Stdout, "Failed: %s\n", err)
return
}
fmt.Fprintf(ui.Stdout, "Contact deleted\n")
}
// This type acts as a readline Listener and handles special behavior for
// the prompt in a conversation. In particular, it swaps temporarily back to
// the normal prompt for command lines (starting with /), and it keeps the
// timestamp in the conversation prompt updated.
type conversationInputConfig struct {
Input *readline.Instance
Config *readline.Config
BaseConfig *readline.Config
PromptFmt string
CommandModeFlag *bool
editingLine []rune
usingConfig bool
stopPromptTimer chan struct{}
}
func (cc *conversationInputConfig) OnChange(line []rune, pos int, key rune) ([]rune, int, bool) {
cc.editingLine = line
// Unset command mode at the beginning of a new read
if line == nil && pos == 0 && key == 0 {
cc.Install()
}
return line, pos, true
}
func (cc *conversationInputConfig) FilterInputRune(key rune) (rune, bool) {
if key == '/' && len(cc.editingLine) == 0 && cc.usingConfig {
// '/' at the beginning of the input triggers command mode
cc.stopPromptTimer <- struct{}{}
cc.usingConfig = false
close(cc.stopPromptTimer)
cc.BaseConfig.Listener = cc.Config.Listener
cc.BaseConfig.FuncFilterInputRune = cc.FilterInputRune
cc.Input.SetConfig(cc.BaseConfig)
*cc.CommandModeFlag = true
// The / is suppressed from the output
return key, false
} else if (key == readline.CharBackspace || key == readline.CharCtrlH) &&
len(cc.editingLine) == 0 && !cc.usingConfig {
// Backspace on an empty command mode line unsets command mode
cc.Install()
return key, false
} else {
return key, true
}
}
func (cc *conversationInputConfig) Install() {
if !cc.usingConfig {
cc.usingConfig = true
cc.Config.FuncFilterInputRune = cc.FilterInputRune
cc.Input.SetConfig(cc.Config)
cc.stopPromptTimer = make(chan struct{})
go cc.updatePromptTimer()
*cc.CommandModeFlag = false
}
}
func (cc *conversationInputConfig) Remove() {
cc.BaseConfig.Listener = nil
if cc.usingConfig {
cc.stopPromptTimer <- struct{}{}
cc.usingConfig = false
close(cc.stopPromptTimer)
cc.BaseConfig.FuncFilterInputRune = nil
cc.Input.SetConfig(cc.BaseConfig)
*cc.CommandModeFlag = true
}
}
func (cc *conversationInputConfig) updatePromptTimer() {
for {
t := time.Now()
cc.Input.SetPrompt(fmt.Sprintf(cc.PromptFmt, t.Format("15:04")))
cc.Input.Refresh()
sec := 61 - t.Second()
select {
case <-time.After(time.Duration(sec) * time.Second):
continue
case <-cc.stopPromptTimer:
return
}
}
}
func (ui *UI) setupConversationPrompt() {
if ui.Input.Config.Listener != nil {
ui.Input.Config.Listener.(*conversationInputConfig).Remove()
}
listener := &conversationInputConfig{
Input: ui.Input,
Config: ui.baseChatConfig.Clone(),
BaseConfig: ui.baseConfig,
PromptFmt: fmt.Sprintf(ui.baseChatConfig.Prompt, "%s", ui.CurrentContact.Data.Nickname),
CommandModeFlag: &ui.commandMode,
}
listener.Config.Listener = listener
listener.Install()
}
func ColoredContactStatus(status ricochet.Contact_Status) string {
switch status {
case ricochet.Contact_UNKNOWN:
return "\x1b[31moffline\x1b[39m"
case ricochet.Contact_OFFLINE:
return "\x1b[31moffline\x1b[39m"
case ricochet.Contact_ONLINE:
return "\x1b[32monline\x1b[39m"
case ricochet.Contact_REQUEST:
return "\x1b[33mcontact request\x1b[39m"
case ricochet.Contact_REJECTED:
return "\x1b[31mrejected\x1b[39m"
default:
return status.String()
}
}
func (ui *UI) EntityByPrefix(prefix string) (*Contact, *ricochet.ContactRequest) {
if len(prefix) < MinContactPrefix || len(prefix) > 16 {
return nil, nil
}
var contact *Contact
for _, c := range ui.Client.Contacts.Contacts {
host, _ := core.PlainHostFromAddress(c.Data.Address)
if prefix == host[:len(prefix)] {
if contact != nil {
// Ambiguous prefix
return nil, nil
}
contact = c
}
}
var request *ricochet.ContactRequest
for _, r := range ui.Client.Contacts.Requests {
host, _ := core.PlainHostFromAddress(r.Address)
if prefix == host[:len(prefix)] {
if contact != nil || request != nil {
return nil, nil
}
request = r
}
}
return contact, request
}
func (ui *UI) PrefixForAddress(address string) string {
host, _ := core.PlainHostFromAddress(address)
prefix := host[:MinContactPrefix]
for _, c := range ui.Client.Contacts.Contacts {
cHost, _ := core.PlainHostFromAddress(c.Data.Address)
if cHost == host {
continue
}
for prefix == cHost[:len(prefix)] && len(prefix) < len(host) {
prefix = host[:len(prefix)+1]
}
}
for _, r := range ui.Client.Contacts.Requests {
rHost, _ := core.PlainHostFromAddress(r.Address)
if rHost == host {
continue
}
for prefix == rHost[:len(prefix)] && len(prefix) < len(host) {
prefix = host[:len(prefix)+1]
}
}
return prefix
}
func (ui *UI) SetCurrentContact(contact *Contact) {
if ui.CurrentContact == contact {
return
}
if ui.CurrentContact != nil {
ui.CurrentContact.Conversation.SetActive(false)
}
ui.CurrentContact = contact
if ui.CurrentContact != nil {
ui.setupConversationPrompt()
fmt.Fprintf(ui.Stdout, "------- \x1b[1m%s\x1b[0m is %s -------\n", contact.Data.Nickname, ColoredContactStatus(contact.Data.Status))
ui.CurrentContact.Conversation.SetActive(true)
} else {
ui.Input.Config.Listener.(*conversationInputConfig).Remove()
ui.Input.SetConfig(ui.baseConfig)
}
}
func (ui *UI) ShowContactRequest(request *ricochet.ContactRequest) {
fmt.Fprintf(ui.Stdout, "\nSomeone would like to add you as a contact:\n\n")
fmt.Fprintf(ui.Stdout, " Address:\t%s\n", request.Address)
// XXX Proper output sanitization here
if len(request.FromNickname) > 0 {
fmt.Fprintf(ui.Stdout, " Name:\t%s\n", request.FromNickname)
}
if len(request.Text) > 0 {
fmt.Fprintf(ui.Stdout, " Message:\t%s\n", request.Text)
}
fmt.Fprintf(ui.Stdout, "\n")
action, err := readline.Line("(a)ccept, (r)eject, or (w)ait: ")
if err != nil {
return
}
if strings.HasPrefix("reject", action) {
_, err := ui.Client.Backend.RejectInboundRequest(context.Background(), request)
if err != nil {
fmt.Fprintf(ui.Stdout, "Failed: %s\n", err)
}
return
} else if !strings.HasPrefix("accept", action) {
// Anything other than accept is wait
fmt.Fprintf(ui.Stdout, "Doing nothing.\n")
return
}
for {
nickname, err := readline.Line("nickname: ")
if err != nil {
return
} else if nickname == "" {
fmt.Fprintf(ui.Stdout, "Aborted.\n")
return
} else if !core.IsNicknameAcceptable(nickname) {
fmt.Fprintf(ui.Stdout, "Invalid nickname '%s'\n", nickname)
continue
} else {
request.FromNickname = nickname
break
}
}
_, err = ui.Client.Backend.AcceptInboundRequest(context.Background(), request)
if err != nil {
fmt.Fprintf(ui.Stdout, "Failed: %s\n", err)
return
}
fmt.Fprintf(ui.Stdout, "Accepted!\n")
}