You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

758 lines
21 KiB

package main
import (
"fmt"
"log"
"os"
"sort"
"strings"
"time"
"github.com/awesome-gocui/gocui"
"samhofi.us/x/keybase"
"unicode/utf8"
)
var (
typeCommands = make(map[string]TypeCommand)
commands = make(map[string]Command)
baseCommands = make([]string, 0)
dev = false
k = keybase.NewKeybase()
channel keybase.Channel
channels []keybase.Channel
stream = false
lastMessage keybase.ChatAPI
lastChat = ""
g *gocui.Gui
)
var config *Config
func main() {
if !k.LoggedIn {
fmt.Println("You are not logged in.")
return
}
var err error
g, err = gocui.NewGui(gocui.OutputNormal, false)
if err != nil {
fmt.Printf("%+v", err)
}
defer g.Close()
g.SetManagerFunc(layout)
RunCommand("config", "load")
go populateList()
go updateChatWindow()
if len(os.Args) > 1 {
os.Args[0] = "join"
RunCommand(os.Args...)
}
fmt.Println("initKeybindings")
if err := initKeybindings(); err != nil {
fmt.Printf("%+v", err)
}
if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
fmt.Printf("%+v", err)
}
go generateChannelTabCompletionSlice()
}
// Gocui basic setup
func layout(g *gocui.Gui) error {
maxX, maxY := g.Size()
if editView, err := g.SetView("Edit", maxX/2-maxX/3+1, maxY/2, maxX-2, maxY/2+10, 0); err != nil {
if err != gocui.ErrUnknownView {
return err
}
editView.Editable = true
editView.Wrap = true
fmt.Fprintln(editView, "Edit window. Should disappear")
}
if feedView, err := g.SetView("Feed", maxX/2-maxX/3, 0, maxX-1, maxY/5, 0); err != nil {
if err != gocui.ErrUnknownView {
return err
}
feedView.Autoscroll = true
feedView.Wrap = true
feedView.Title = "Feed Window"
printInfo("Feed Window - If you are mentioned or receive a PM it will show here")
}
if chatView, err2 := g.SetView("Chat", maxX/2-maxX/3, maxY/5+1, maxX-1, maxY-5, 0); err2 != nil {
if err2 != gocui.ErrUnknownView {
return err2
}
chatView.Autoscroll = true
chatView.Wrap = true
welcomeText := basicStyle.stylize("Welcome $USER!\n\nYour chats will appear here.\nSupported commands are as follows:\n")
welcomeText = welcomeText.replace("$USER", config.Colors.Message.Mention.stylize(k.Username))
fmt.Fprintln(chatView, welcomeText.string())
RunCommand("help")
}
if inputView, err3 := g.SetView("Input", maxX/2-maxX/3, maxY-4, maxX-1, maxY-1, 0); err3 != nil {
if err3 != gocui.ErrUnknownView {
return err3
}
if _, err := g.SetCurrentView("Input"); err != nil {
return err
}
inputView.Editable = true
inputView.Wrap = true
inputView.Title = fmt.Sprintf(" Not in a chat - write `%sj` to join", config.Basics.CmdPrefix)
g.Cursor = true
}
if listView, err4 := g.SetView("List", 0, 0, maxX/2-maxX/3-1, maxY-1, 0); err4 != nil {
if err4 != gocui.ErrUnknownView {
return err4
}
listView.Title = "Channels"
fmt.Fprintf(listView, "Lists\nWindow\nTo view\n activity")
}
return nil
}
func scrollViewUp(v *gocui.View) error {
scrollView(v, -1)
return nil
}
func scrollViewDown(v *gocui.View) error {
scrollView(v, 1)
return nil
}
func scrollView(v *gocui.View, delta int) error {
if v != nil {
_, y := v.Size()
ox, oy := v.Origin()
if oy+delta > strings.Count(v.ViewBuffer(), "\n")-y {
v.Autoscroll = true
} else {
v.Autoscroll = false
if err := v.SetOrigin(ox, oy+delta); err != nil {
return err
}
}
}
return nil
}
func autoScrollView(vn string) error {
v, err := g.View(vn)
if err != nil {
return err
} else if v != nil {
v.Autoscroll = true
}
return nil
}
func initKeybindings() error {
if err := g.SetKeybinding("", gocui.KeyPgup, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
cv, _ := g.View("Chat")
err := scrollViewUp(cv)
if err != nil {
return err
}
return nil
}); err != nil {
return err
}
if err := g.SetKeybinding("", gocui.KeyPgdn, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
cv, _ := g.View("Chat")
err := scrollViewDown(cv)
if err != nil {
return err
}
return nil
}); err != nil {
return err
}
if err := g.SetKeybinding("", gocui.KeyEsc, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
autoScrollView("Chat")
return nil
}); err != nil {
return err
}
if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
input, err := getInputString("Input")
if err != nil {
return err
}
if input != "" {
clearView("Input")
return nil
}
return gocui.ErrQuit
}); err != nil {
return err
}
if err := g.SetKeybinding("", gocui.KeyCtrlZ, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
cmdJoin([]string{"/join", lastChat})
return nil
}); err != nil {
return err
}
if err := g.SetKeybinding("Edit", gocui.KeyCtrlC, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
popupView("Chat")
popupView("Input")
clearView("Edit")
return nil
}); err != nil {
return err
}
if err := g.SetKeybinding("Input", gocui.KeyEnter, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
return handleInput("Input")
}); err != nil {
return err
}
if err := g.SetKeybinding("Input", gocui.KeyTab, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
return handleTab("Input")
}); err != nil {
return err
}
if err := g.SetKeybinding("Edit", gocui.KeyEnter, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
popupView("Chat")
popupView("Input")
return handleInput("Edit")
}); err != nil {
return err
}
if err := g.SetKeybinding("Input", gocui.KeyArrowUp, gocui.ModNone,
func(g *gocui.Gui, v *gocui.View) error {
RunCommand("edit")
return nil
}); err != nil {
return err
}
return nil
}
// End gocui basic setup
// Gocui helper funcs
func setViewTitle(viewName string, title string) {
g.Update(func(g *gocui.Gui) error {
updatingView, err := g.View(viewName)
if err != nil {
return err
}
updatingView.Title = title
return nil
})
}
func getViewTitle(viewName string) string {
view, err := g.View(viewName)
if err != nil {
// in case there is active tab completion, filter that to just the view title and not the completion options.
printError(fmt.Sprintf("Error getting view title: %s", err))
return ""
}
return strings.Split(view.Title, "||")[0]
}
func popupView(viewName string) {
_, err := g.SetCurrentView(viewName)
if err != nil {
printError(fmt.Sprintf("%+v", err))
}
_, err = g.SetViewOnTop(viewName)
if err != nil {
printError(fmt.Sprintf("%+v", err))
}
g.Update(func(g *gocui.Gui) error {
updatingView, err := g.View(viewName)
if err != nil {
return err
}
updatingView.MoveCursor(0, 0)
return nil
})
}
func moveCursorToEnd(viewName string) {
g.Update(func(g *gocui.Gui) error {
inputView, err := g.View(viewName)
if err != nil {
return err
}
inputString, _ := getInputString(viewName)
stringLen := len(inputString)
maxX, _ := inputView.Size()
x := stringLen % maxX
y := stringLen / maxX
inputView.SetCursor(0, 0)
inputView.SetOrigin(0, 0)
inputView.MoveCursor(x, y)
return nil
})
}
func clearView(viewName string) {
g.Update(func(g *gocui.Gui) error {
inputView, err := g.View(viewName)
if err != nil {
return err
}
inputView.Clear()
inputView.SetCursor(0, 0)
inputView.SetOrigin(0, 0)
return nil
})
}
func writeToView(viewName string, message string) {
g.Update(func(g *gocui.Gui) error {
updatingView, err := g.View(viewName)
if err != nil {
return err
}
for _, c := range message {
updatingView.EditWrite(c)
}
return nil
})
}
// this removes formatting
func printError(message string) {
printErrorF(message)
}
func printErrorF(message string, parts ...StyledString) {
printToView("Feed", config.Colors.Feed.Error.sprintf(removeFormatting(message), parts...).string())
}
// this removes formatting
func printInfo(message string) {
printInfoF(message)
}
func printInfoStyledString(message StyledString) {
printInfoF("$TEXT", message)
}
// this removes formatting
func printInfoF(message string, parts ...StyledString) {
printToView("Feed", config.Colors.Feed.Basic.sprintf(removeFormatting(message), parts...).string())
}
func printToView(viewName string, message string) {
g.Update(func(g *gocui.Gui) error {
updatingView, err := g.View(viewName)
if err != nil {
return err
}
if config.Basics.UnicodeEmojis {
message = emojiUnicodeConvert(message)
}
fmt.Fprintf(updatingView, "%s\n", message)
return nil
})
}
// End gocui helper funcs
// Update/Populate views automatically
func updateChatWindow() {
runOpts := keybase.RunOptions{
Dev: dev,
}
k.Run(func(api keybase.ChatAPI) {
handleMessage(api)
},
runOpts)
}
func populateChat() {
lastMessage.ID = 0
chat := k.NewChat(channel)
maxX, _ := g.Size()
api, err := chat.Read(maxX / 2)
if err != nil || api.Result == nil {
for _, testChan := range channels {
if channel.Name == testChan.Name {
channel = testChan
channel.TopicName = "general"
}
}
chat = k.NewChat(channel)
_, err2 := chat.Read(2)
if err2 != nil {
printError(fmt.Sprintf("%+v", err))
return
}
go populateChat()
go generateChannelTabCompletionSlice()
return
}
var printMe []string
var actuallyPrintMe string
if len(api.Result.Messages) > 0 {
lastMessage.ID = api.Result.Messages[0].Msg.ID
}
for _, message := range api.Result.Messages {
if message.Msg.Content.Type == "text" || message.Msg.Content.Type == "attachment" {
if lastMessage.ID < 1 {
lastMessage.ID = message.Msg.ID
}
var apiCast keybase.ChatAPI
apiCast.Msg = &message.Msg
newMessage := formatOutput(apiCast).string()
printMe = append(printMe, newMessage)
}
}
for i := len(printMe) - 1; i >= 0; i-- {
actuallyPrintMe += printMe[i]
if i > 0 {
actuallyPrintMe += "\n"
}
}
printToView("Chat", actuallyPrintMe)
go populateList()
}
func populateList() {
_, maxY := g.Size()
if testVar, err := k.ChatList(); err != nil {
log.Printf("%+v", err)
} else {
clearView("List")
conversationSlice := testVar.Result.Conversations
sort.SliceStable(conversationSlice, func(i, j int) bool {
return conversationSlice[i].ActiveAt > conversationSlice[j].ActiveAt
})
var textBase = config.Colors.Channels.Basic.stylize("")
var recentPMs = textBase.append(config.Colors.Channels.Header.stylize("---[PMs]---\n"))
var recentPMsCount = 0
var recentChannels = textBase.append(config.Colors.Channels.Header.stylize("---[Teams]---\n"))
var recentChannelsCount = 0
for _, s := range conversationSlice {
channels = append(channels, s.Channel)
if s.Channel.MembersType == keybase.TEAM {
recentChannelsCount++
if recentChannelsCount <= ((maxY - 2) / 3) {
channel := fmt.Sprintf("%s\n\t#%s\n", s.Channel.Name, s.Channel.TopicName)
if s.Unread {
recentChannels = recentChannels.append(config.Colors.Channels.Unread.stylize("*" + channel))
} else {
recentChannels = recentChannels.appendString(channel)
}
}
} else {
recentPMsCount++
if recentPMsCount <= ((maxY - 2) / 3) {
pmName := fmt.Sprintf("%s\n", cleanChannelName(s.Channel.Name))
if s.Unread {
recentPMs = recentPMs.append(config.Colors.Channels.Unread.stylize("*" + pmName))
} else {
recentPMs = recentPMs.appendString(pmName)
}
}
}
}
time.Sleep(1 * time.Millisecond)
printToView("List", fmt.Sprintf("%s%s", recentPMs.string(), recentChannels.string()))
generateRecentTabCompletionSlice()
}
}
// End update/populate views automatically
// Formatting
func formatMessageBody(body string) StyledString {
body = strings.Replace(body, "```", "\n<code>\n", -1)
message := config.Colors.Message.Body.stylize(body)
message = message.colorRegex(`@[\w_]*([\.#][\w_]+)*`, config.Colors.Message.LinkKeybase)
message = colorReplaceMentionMe(message)
// TODO when gocui actually fixes there shit with formatting, then un comment these lines
// message = message.colorRegex(`_[^_]*_`, config.Colors.Message.Body.withItalic())
// message = message.colorRegex(`~[^~]*~`, config.Colors.Message.Body.withStrikethrough())
message = message.colorRegex(`@[\w_]*([\.#][\w_]+)*`, config.Colors.Message.LinkKeybase)
// TODO change how bold, italic etc works, so it uses boldOn boldOff ([1m and [22m)
message = message.colorRegex(`\*[^\*]*\*`, config.Colors.Message.Body.withBold())
message = message.colorRegex("^>.*$", config.Colors.Message.Quote)
message = message.regexReplaceFunc("\n<code>(.*\n)*<code>\n", func(match string) string {
maxWidth, _ := g.Size()
output := ""
match = strings.Replace(strings.Replace(match, "```", "\n<code>\n", -1), "\t", " ", -1)
match = removeFormatting(match)
lines := strings.Split(match, "\n")
for _, line := range lines {
maxLineLength := maxWidth/2 + maxWidth/3 - 2
spaces := maxLineLength - utf8.RuneCountInString(line)
for i := 1; spaces < 0; i++ {
spaces = i*maxLineLength - utf8.RuneCountInString(line)
}
output += line + strings.Repeat(" ", spaces) + "\n"
}
// TODO stylize should remove formatting - in general everything should
return config.Colors.Message.Code.stylize(output).stringFollowedByStyle(message.style)
})
message = message.colorRegex("`[^`]*`", config.Colors.Message.Code)
// mention URL
message = message.colorRegex(`(https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*))`, config.Colors.Message.LinkURL)
return message
}
// TODO use this more
func formatChannel(ch keybase.Channel) StyledString {
return config.Colors.Message.LinkKeybase.stylize(fmt.Sprintf("@%s#%s", ch.Name, ch.TopicName))
}
func colorReplaceMentionMe(msg StyledString) StyledString {
return msg.colorRegex(`(@?\b`+k.Username+`\b)`, config.Colors.Message.Mention)
}
func colorUsername(username string) StyledString {
var color = config.Colors.Message.SenderDefault
if username == k.Username {
color = config.Colors.Message.Mention
}
return color.stylize(username)
}
func cleanChannelName(c string) string {
newChannelName := strings.Replace(c, fmt.Sprintf("%s,", k.Username), "", 1)
return strings.Replace(newChannelName, fmt.Sprintf(",%s", k.Username), "", 1)
}
func formatMessage(api keybase.ChatAPI, formatString string) StyledString {
msg := api.Msg
ret := config.Colors.Message.Header.stylize("")
msgType := msg.Content.Type
switch msgType {
case "text", "attachment":
ret = config.Colors.Message.Header.stylize(formatString)
tm := time.Unix(int64(msg.SentAt), 0)
var body = formatMessageBody(msg.Content.Text.Body)
if msgType == "attachment" {
body = config.Colors.Message.Body.stylize("$TITLE\n$FILE")
attachment := msg.Content.Attachment
body = body.replaceString("$TITLE", attachment.Object.Title)
body = body.replace("$FILE", config.Colors.Message.Attachment.stylize(fmt.Sprintf("[Attachment: %s]", attachment.Object.Filename)))
}
reply := ""
if msg.Content.Text.ReplyTo != 0 {
chat := k.NewChat(channel)
replyMsg, replErr := chat.ReadMessage(msg.Content.Text.ReplyTo)
if replErr == nil {
replyUser := replyMsg.Result.Messages[0].Msg.Sender.Username
replyBody := ""
if replyMsg.Result.Messages[0].Msg.Content.Type == "text" {
replyBody = replyMsg.Result.Messages[0].Msg.Content.Text.Body
}
reply = fmt.Sprintf("\nReplyTo> %s: %s\n", replyUser, replyBody)
}
}
user := colorUsername(msg.Sender.Username)
device := config.Colors.Message.SenderDevice.stylize(msg.Sender.DeviceName)
msgID := config.Colors.Message.ID.stylize(fmt.Sprintf("%d", msg.ID))
date := config.Colors.Message.Time.stylize(tm.Format(config.Formatting.DateFormat))
msgTime := config.Colors.Message.Time.stylize(tm.Format(config.Formatting.TimeFormat))
c0ck := config.Colors.Message.Quote.stylize(reply)
channelName := config.Colors.Message.ID.stylize(fmt.Sprintf("@%s#%s", msg.Channel.Name, msg.Channel.TopicName))
ret = ret.replace("$REPL", c0ck)
ret = ret.replace("$MSG", body)
ret = ret.replace("$USER", user)
ret = ret.replace("$DEVICE", device)
ret = ret.replace("$ID", msgID)
ret = ret.replace("$TIME", msgTime)
ret = ret.replace("$DATE", date)
ret = ret.replace("$TEAM", channelName)
ret = ret.replace("$TAGS", getUserFlags(api.Msg.Sender.Username))
}
return ret
}
func formatOutput(api keybase.ChatAPI) StyledString {
format := config.Formatting.OutputFormat
if stream {
format = config.Formatting.OutputStreamFormat
}
return formatMessage(api, format)
}
// End formatting
// Input handling
func handleMessage(api keybase.ChatAPI) {
if api.ErrorListen != nil {
printError(fmt.Sprintf("%+v", api.ErrorListen))
return
}
if _, ok := typeCommands[api.Msg.Content.Type]; ok {
if api.Msg.Channel.MembersType == channel.MembersType && cleanChannelName(api.Msg.Channel.Name) == channel.Name {
if channel.MembersType == keybase.TEAM && channel.TopicName != api.Msg.Channel.TopicName {
} else {
go typeCommands[api.Msg.Content.Type].Exec(api)
}
}
}
if api.Msg.Content.Type == "text" || api.Msg.Content.Type == "attachment" {
go populateList()
msgSender := api.Msg.Sender.Username
if !stream {
if msgSender != k.Username {
if api.Msg.Channel.MembersType == keybase.TEAM {
topicName := api.Msg.Channel.TopicName
for _, m := range api.Msg.Content.Text.UserMentions {
if m.Text == k.Username {
// We are in a team
if topicName != channel.TopicName {
printInfoStyledString(formatMessage(api, config.Formatting.OutputMentionFormat))
fmt.Print("\a")
}
break
}
}
} else {
if msgSender != channel.Name {
printInfoStyledString(formatMessage(api, config.Formatting.PMFormat))
fmt.Print("\a")
}
}
}
if api.Msg.Channel.MembersType == channel.MembersType && cleanChannelName(api.Msg.Channel.Name) == channel.Name {
if channel.MembersType == keybase.USER || channel.MembersType == keybase.TEAM && channel.TopicName == api.Msg.Channel.TopicName {
printToView("Chat", formatOutput(api).string())
chat := k.NewChat(channel)
lastMessage.ID = api.Msg.ID
chat.Read(api.Msg.ID)
}
}
} else {
if api.Msg.Channel.MembersType == keybase.TEAM {
printToView("Chat", formatOutput(api).string())
} else {
printToView("Chat", formatMessage(api, config.Formatting.PMFormat).string())
}
}
} else {
//TODO: For edit/delete run this
if api.Msg.Channel.MembersType == channel.MembersType && cleanChannelName(api.Msg.Channel.Name) == channel.Name {
go populateChat()
}
}
}
func getInputString(viewName string) (string, error) {
inputView, err := g.View(viewName)
if err != nil {
return "", err
}
retString := inputView.Buffer()
retString = strings.Replace(retString, "\n", "", 800)
return retString, err
}
func deleteEmpty(s []string) []string {
var r []string
for _, str := range s {
if str != "" {
r = append(r, str)
}
}
return r
}
func handleInput(viewName string) error {
clearView(viewName)
inputString, _ := getInputString(viewName)
if inputString == "" {
return nil
}
if strings.HasPrefix(inputString, config.Basics.CmdPrefix) {
cmd := deleteEmpty(strings.Split(inputString[len(config.Basics.CmdPrefix):], " "))
if len(cmd) < 1 {
return nil
}
if c, ok := commands[cmd[0]]; ok {
c.Exec(cmd)
return nil
} else if cmd[0] == "q" || cmd[0] == "quit" {
return gocui.ErrQuit
} else {
printError(fmt.Sprintf("Command '%s' not recognized", cmd[0]))
return nil
}
}
if inputString[:1] == "+" || inputString[:1] == "-" {
cmd := strings.Split(inputString, " ")
cmd[0] = inputString[:1]
RunCommand(cmd...)
} else {
inputString = resolveRootEmojis(inputString)
go sendChat(inputString)
}
// restore any tab completion view titles on input commit
if newViewTitle := getViewTitle(viewName); newViewTitle != "" {
setViewTitle(viewName, newViewTitle)
}
go populateList()
return nil
}
func sendChat(message string) {
autoScrollView("Chat")
chat := k.NewChat(channel)
_, err := chat.Send(message)
if err != nil {
printError(fmt.Sprintf("There was an error %+v", err))
}
}
// End input handling
func quit(g *gocui.Gui, v *gocui.View) error {
return gocui.ErrQuit
}
// RegisterTypeCommand registers a command to be used within the client
func RegisterTypeCommand(c TypeCommand) error {
var notAdded string
for _, cmd := range c.Cmd {
if _, ok := typeCommands[cmd]; !ok {
typeCommands[cmd] = c
continue
}
notAdded = fmt.Sprintf("%s, %s", notAdded, cmd)
}
if notAdded != "" {
return fmt.Errorf("The following aliases were not added because they already exist: %s", notAdded)
}
return nil
}
// RegisterCommand registers a command to be used within the client
func RegisterCommand(c Command) error {
var notAdded string
for i, cmd := range c.Cmd {
if _, ok := commands[cmd]; !ok {
if i == 0 {
baseCommands = append(baseCommands, cmd)
}
commands[cmd] = c
continue
}
notAdded = fmt.Sprintf("%s, %s", notAdded, cmd)
}
if notAdded != "" {
return fmt.Errorf("The following aliases were not added because they already exist: %s", notAdded)
}
return nil
}
// RunCommand calls a command as if it was run by the user
func RunCommand(c ...string) {
commands[c[0]].Exec(c)
}