648 lines
12 KiB
Go
648 lines
12 KiB
Go
// Package main implements the chat-cli terminal client.
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"git.eeqj.de/sneak/chat/cmd/chat-cli/api"
|
|
)
|
|
|
|
const (
|
|
// splitParts is the number of parts to split a command into (command + args).
|
|
splitParts = 2
|
|
// pollTimeout is the long-poll timeout in seconds.
|
|
pollTimeout = 15
|
|
// pollRetryDelay is the delay before retrying a failed poll.
|
|
pollRetryDelay = 2 * time.Second
|
|
)
|
|
|
|
// App holds the application state.
|
|
type App struct {
|
|
ui *UI
|
|
client *api.Client
|
|
|
|
mu sync.Mutex
|
|
nick string
|
|
target string // current target (#channel or nick for DM)
|
|
connected bool
|
|
lastMsgID string
|
|
stopPoll chan struct{}
|
|
}
|
|
|
|
func main() {
|
|
app := &App{
|
|
ui: NewUI(),
|
|
nick: "guest",
|
|
}
|
|
|
|
app.ui.OnInput(app.handleInput)
|
|
app.ui.SetStatus(app.nick, "", "disconnected")
|
|
|
|
app.ui.AddStatus("Welcome to chat-cli — an IRC-style client")
|
|
app.ui.AddStatus("Type [yellow]/connect <server-url>[white] to begin, or [yellow]/help[white] for commands")
|
|
|
|
err := app.ui.Run()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func (a *App) handleInput(text string) {
|
|
if strings.HasPrefix(text, "/") {
|
|
a.handleCommand(text)
|
|
|
|
return
|
|
}
|
|
|
|
// Plain text → PRIVMSG to current target.
|
|
a.mu.Lock()
|
|
target := a.target
|
|
connected := a.connected
|
|
a.mu.Unlock()
|
|
|
|
if !connected {
|
|
a.ui.AddStatus("[red]Not connected. Use /connect <url>")
|
|
|
|
return
|
|
}
|
|
|
|
if target == "" {
|
|
a.ui.AddStatus("[red]No target. Use /join #channel or /query nick")
|
|
|
|
return
|
|
}
|
|
|
|
err := a.client.SendMessage(&api.Message{
|
|
Command: "PRIVMSG",
|
|
To: target,
|
|
Body: []string{text},
|
|
})
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Send error: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
// Echo locally.
|
|
ts := time.Now().Format("15:04")
|
|
|
|
a.mu.Lock()
|
|
nick := a.nick
|
|
a.mu.Unlock()
|
|
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [green]<%s>[white] %s", ts, nick, text))
|
|
}
|
|
|
|
func (a *App) handleCommand(text string) {
|
|
parts := strings.SplitN(text, " ", splitParts)
|
|
cmd := strings.ToLower(parts[0])
|
|
|
|
args := ""
|
|
if len(parts) > 1 {
|
|
args = parts[1]
|
|
}
|
|
|
|
switch cmd {
|
|
case "/connect":
|
|
a.cmdConnect(args)
|
|
case "/nick":
|
|
a.cmdNick(args)
|
|
case "/join":
|
|
a.cmdJoin(args)
|
|
case "/part":
|
|
a.cmdPart(args)
|
|
case "/msg":
|
|
a.cmdMsg(args)
|
|
case "/query":
|
|
a.cmdQuery(args)
|
|
case "/topic":
|
|
a.cmdTopic(args)
|
|
case "/names":
|
|
a.cmdNames()
|
|
case "/list":
|
|
a.cmdList()
|
|
case "/window", "/w":
|
|
a.cmdWindow(args)
|
|
case "/quit":
|
|
a.cmdQuit()
|
|
case "/help":
|
|
a.cmdHelp()
|
|
default:
|
|
a.ui.AddStatus("[red]Unknown command: " + cmd)
|
|
}
|
|
}
|
|
|
|
func (a *App) cmdConnect(serverURL string) {
|
|
if serverURL == "" {
|
|
a.ui.AddStatus("[red]Usage: /connect <server-url>")
|
|
|
|
return
|
|
}
|
|
|
|
serverURL = strings.TrimRight(serverURL, "/")
|
|
|
|
a.ui.AddStatus(fmt.Sprintf("Connecting to %s...", serverURL))
|
|
|
|
a.mu.Lock()
|
|
nick := a.nick
|
|
a.mu.Unlock()
|
|
|
|
client := api.NewClient(serverURL)
|
|
|
|
resp, err := client.CreateSession(nick)
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Connection failed: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
a.mu.Lock()
|
|
a.client = client
|
|
a.nick = resp.Nick
|
|
a.connected = true
|
|
a.lastMsgID = ""
|
|
a.mu.Unlock()
|
|
|
|
a.ui.AddStatus(fmt.Sprintf("[green]Connected! Nick: %s, Session: %s", resp.Nick, resp.SessionID))
|
|
a.ui.SetStatus(resp.Nick, "", "connected")
|
|
|
|
// Start polling.
|
|
a.stopPoll = make(chan struct{})
|
|
go a.pollLoop()
|
|
}
|
|
|
|
func (a *App) cmdNick(nick string) {
|
|
if nick == "" {
|
|
a.ui.AddStatus("[red]Usage: /nick <name>")
|
|
|
|
return
|
|
}
|
|
|
|
a.mu.Lock()
|
|
connected := a.connected
|
|
a.mu.Unlock()
|
|
|
|
if !connected {
|
|
a.mu.Lock()
|
|
a.nick = nick
|
|
a.mu.Unlock()
|
|
a.ui.AddStatus(fmt.Sprintf("Nick set to %s (will be used on connect)", nick))
|
|
|
|
return
|
|
}
|
|
|
|
err := a.client.SendMessage(&api.Message{
|
|
Command: "NICK",
|
|
Body: []string{nick},
|
|
})
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Nick change failed: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
a.mu.Lock()
|
|
a.nick = nick
|
|
target := a.target
|
|
a.mu.Unlock()
|
|
a.ui.SetStatus(nick, target, "connected")
|
|
a.ui.AddStatus("Nick changed to " + nick)
|
|
}
|
|
|
|
func (a *App) cmdJoin(channel string) {
|
|
if channel == "" {
|
|
a.ui.AddStatus("[red]Usage: /join #channel")
|
|
|
|
return
|
|
}
|
|
|
|
if !strings.HasPrefix(channel, "#") {
|
|
channel = "#" + channel
|
|
}
|
|
|
|
a.mu.Lock()
|
|
connected := a.connected
|
|
a.mu.Unlock()
|
|
|
|
if !connected {
|
|
a.ui.AddStatus("[red]Not connected")
|
|
|
|
return
|
|
}
|
|
|
|
err := a.client.JoinChannel(channel)
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Join failed: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
a.mu.Lock()
|
|
a.target = channel
|
|
nick := a.nick
|
|
a.mu.Unlock()
|
|
|
|
a.ui.SwitchToBuffer(channel)
|
|
a.ui.AddLine(channel, "[yellow]*** Joined "+channel)
|
|
a.ui.SetStatus(nick, channel, "connected")
|
|
}
|
|
|
|
func (a *App) cmdPart(channel string) {
|
|
a.mu.Lock()
|
|
if channel == "" {
|
|
channel = a.target
|
|
}
|
|
|
|
connected := a.connected
|
|
a.mu.Unlock()
|
|
|
|
if channel == "" || !strings.HasPrefix(channel, "#") {
|
|
a.ui.AddStatus("[red]No channel to part")
|
|
|
|
return
|
|
}
|
|
|
|
if !connected {
|
|
a.ui.AddStatus("[red]Not connected")
|
|
|
|
return
|
|
}
|
|
|
|
err := a.client.PartChannel(channel)
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Part failed: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
a.ui.AddLine(channel, "[yellow]*** Left "+channel)
|
|
|
|
a.mu.Lock()
|
|
if a.target == channel {
|
|
a.target = ""
|
|
}
|
|
|
|
nick := a.nick
|
|
a.mu.Unlock()
|
|
|
|
a.ui.SwitchBuffer(0)
|
|
a.ui.SetStatus(nick, "", "connected")
|
|
}
|
|
|
|
func (a *App) cmdMsg(args string) {
|
|
parts := strings.SplitN(args, " ", splitParts)
|
|
if len(parts) < splitParts {
|
|
a.ui.AddStatus("[red]Usage: /msg <nick> <text>")
|
|
|
|
return
|
|
}
|
|
|
|
target, text := parts[0], parts[1]
|
|
|
|
a.mu.Lock()
|
|
connected := a.connected
|
|
nick := a.nick
|
|
a.mu.Unlock()
|
|
|
|
if !connected {
|
|
a.ui.AddStatus("[red]Not connected")
|
|
|
|
return
|
|
}
|
|
|
|
err := a.client.SendMessage(&api.Message{
|
|
Command: "PRIVMSG",
|
|
To: target,
|
|
Body: []string{text},
|
|
})
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Send failed: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
ts := time.Now().Format("15:04")
|
|
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [green]<%s>[white] %s", ts, nick, text))
|
|
}
|
|
|
|
func (a *App) cmdQuery(nick string) {
|
|
if nick == "" {
|
|
a.ui.AddStatus("[red]Usage: /query <nick>")
|
|
|
|
return
|
|
}
|
|
|
|
a.mu.Lock()
|
|
a.target = nick
|
|
myNick := a.nick
|
|
a.mu.Unlock()
|
|
|
|
a.ui.SwitchToBuffer(nick)
|
|
a.ui.SetStatus(myNick, nick, "connected")
|
|
}
|
|
|
|
func (a *App) cmdTopic(args string) {
|
|
a.mu.Lock()
|
|
target := a.target
|
|
connected := a.connected
|
|
a.mu.Unlock()
|
|
|
|
if !connected {
|
|
a.ui.AddStatus("[red]Not connected")
|
|
|
|
return
|
|
}
|
|
|
|
if !strings.HasPrefix(target, "#") {
|
|
a.ui.AddStatus("[red]Not in a channel")
|
|
|
|
return
|
|
}
|
|
|
|
if args == "" {
|
|
// Query topic.
|
|
err := a.client.SendMessage(&api.Message{
|
|
Command: "TOPIC",
|
|
To: target,
|
|
})
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Topic query failed: %v", err))
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
err := a.client.SendMessage(&api.Message{
|
|
Command: "TOPIC",
|
|
To: target,
|
|
Body: []string{args},
|
|
})
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Topic set failed: %v", err))
|
|
}
|
|
}
|
|
|
|
func (a *App) cmdNames() {
|
|
a.mu.Lock()
|
|
target := a.target
|
|
connected := a.connected
|
|
a.mu.Unlock()
|
|
|
|
if !connected {
|
|
a.ui.AddStatus("[red]Not connected")
|
|
|
|
return
|
|
}
|
|
|
|
if !strings.HasPrefix(target, "#") {
|
|
a.ui.AddStatus("[red]Not in a channel")
|
|
|
|
return
|
|
}
|
|
|
|
members, err := a.client.GetMembers(target)
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]Names failed: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
a.ui.AddLine(target, fmt.Sprintf("[cyan]*** Members of %s: %s", target, strings.Join(members, " ")))
|
|
}
|
|
|
|
func (a *App) cmdList() {
|
|
a.mu.Lock()
|
|
connected := a.connected
|
|
a.mu.Unlock()
|
|
|
|
if !connected {
|
|
a.ui.AddStatus("[red]Not connected")
|
|
|
|
return
|
|
}
|
|
|
|
channels, err := a.client.ListChannels()
|
|
if err != nil {
|
|
a.ui.AddStatus(fmt.Sprintf("[red]List failed: %v", err))
|
|
|
|
return
|
|
}
|
|
|
|
a.ui.AddStatus("[cyan]*** Channel list:")
|
|
|
|
for _, ch := range channels {
|
|
a.ui.AddStatus(fmt.Sprintf(" %s (%d members) %s", ch.Name, ch.Members, ch.Topic))
|
|
}
|
|
|
|
a.ui.AddStatus("[cyan]*** End of channel list")
|
|
}
|
|
|
|
func (a *App) cmdWindow(args string) {
|
|
if args == "" {
|
|
a.ui.AddStatus("[red]Usage: /window <number>")
|
|
|
|
return
|
|
}
|
|
|
|
n := 0
|
|
_, _ = fmt.Sscanf(args, "%d", &n)
|
|
a.ui.SwitchBuffer(n)
|
|
|
|
a.mu.Lock()
|
|
nick := a.nick
|
|
a.mu.Unlock()
|
|
|
|
// Update target based on buffer.
|
|
if n < a.ui.BufferCount() {
|
|
buf := a.ui.buffers[n]
|
|
if buf.Name != "(status)" {
|
|
a.mu.Lock()
|
|
a.target = buf.Name
|
|
a.mu.Unlock()
|
|
a.ui.SetStatus(nick, buf.Name, "connected")
|
|
} else {
|
|
a.ui.SetStatus(nick, "", "connected")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (a *App) cmdQuit() {
|
|
a.mu.Lock()
|
|
if a.connected && a.client != nil {
|
|
_ = a.client.SendMessage(&api.Message{Command: "QUIT"})
|
|
}
|
|
|
|
if a.stopPoll != nil {
|
|
close(a.stopPoll)
|
|
}
|
|
a.mu.Unlock()
|
|
a.ui.Stop()
|
|
}
|
|
|
|
func (a *App) cmdHelp() {
|
|
help := []string{
|
|
"[cyan]*** chat-cli commands:",
|
|
" /connect <url> — Connect to server",
|
|
" /nick <name> — Change nickname",
|
|
" /join #channel — Join channel",
|
|
" /part [#chan] — Leave channel",
|
|
" /msg <nick> <text> — Send DM",
|
|
" /query <nick> — Open DM window",
|
|
" /topic [text] — View/set topic",
|
|
" /names — List channel members",
|
|
" /list — List channels",
|
|
" /window <n> — Switch buffer (Alt+0-9)",
|
|
" /quit — Disconnect and exit",
|
|
" /help — This help",
|
|
" Plain text sends to current target.",
|
|
}
|
|
for _, line := range help {
|
|
a.ui.AddStatus(line)
|
|
}
|
|
}
|
|
|
|
// pollLoop long-polls for messages in the background.
|
|
func (a *App) pollLoop() {
|
|
for {
|
|
select {
|
|
case <-a.stopPoll:
|
|
return
|
|
default:
|
|
}
|
|
|
|
a.mu.Lock()
|
|
client := a.client
|
|
lastID := a.lastMsgID
|
|
a.mu.Unlock()
|
|
|
|
if client == nil {
|
|
return
|
|
}
|
|
|
|
msgs, err := client.PollMessages(lastID, pollTimeout)
|
|
if err != nil {
|
|
// Transient error — retry after delay.
|
|
time.Sleep(pollRetryDelay)
|
|
|
|
continue
|
|
}
|
|
|
|
for _, msg := range msgs {
|
|
a.handleServerMessage(&msg)
|
|
|
|
if msg.ID != "" {
|
|
a.mu.Lock()
|
|
a.lastMsgID = msg.ID
|
|
a.mu.Unlock()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (a *App) handleServerMessage(msg *api.Message) {
|
|
var ts string
|
|
|
|
if msg.TS != "" {
|
|
t := msg.ParseTS()
|
|
ts = t.Local().Format("15:04") //nolint:gosmopolitan // CLI displays local time intentionally
|
|
} else {
|
|
ts = time.Now().Format("15:04")
|
|
}
|
|
|
|
a.mu.Lock()
|
|
myNick := a.nick
|
|
a.mu.Unlock()
|
|
|
|
switch msg.Command {
|
|
case "PRIVMSG":
|
|
lines := msg.BodyLines()
|
|
text := strings.Join(lines, " ")
|
|
|
|
if msg.From == myNick {
|
|
// Skip our own echoed messages (already displayed locally).
|
|
return
|
|
}
|
|
|
|
target := msg.To
|
|
if !strings.HasPrefix(target, "#") {
|
|
// DM — use sender's nick as buffer name.
|
|
target = msg.From
|
|
}
|
|
|
|
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [green]<%s>[white] %s", ts, msg.From, text))
|
|
|
|
case "JOIN":
|
|
target := msg.To
|
|
if target != "" {
|
|
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [yellow]*** %s has joined %s", ts, msg.From, target))
|
|
}
|
|
|
|
case "PART":
|
|
target := msg.To
|
|
lines := msg.BodyLines()
|
|
|
|
reason := strings.Join(lines, " ")
|
|
if target != "" {
|
|
if reason != "" {
|
|
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [yellow]*** %s has left %s (%s)", ts, msg.From, target, reason))
|
|
} else {
|
|
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [yellow]*** %s has left %s", ts, msg.From, target))
|
|
}
|
|
}
|
|
|
|
case "QUIT":
|
|
lines := msg.BodyLines()
|
|
|
|
reason := strings.Join(lines, " ")
|
|
if reason != "" {
|
|
a.ui.AddStatus(fmt.Sprintf("[gray]%s [yellow]*** %s has quit (%s)", ts, msg.From, reason))
|
|
} else {
|
|
a.ui.AddStatus(fmt.Sprintf("[gray]%s [yellow]*** %s has quit", ts, msg.From))
|
|
}
|
|
|
|
case "NICK":
|
|
lines := msg.BodyLines()
|
|
|
|
newNick := ""
|
|
if len(lines) > 0 {
|
|
newNick = lines[0]
|
|
}
|
|
|
|
if msg.From == myNick && newNick != "" {
|
|
a.mu.Lock()
|
|
a.nick = newNick
|
|
target := a.target
|
|
a.mu.Unlock()
|
|
a.ui.SetStatus(newNick, target, "connected")
|
|
}
|
|
|
|
a.ui.AddStatus(fmt.Sprintf("[gray]%s [yellow]*** %s is now known as %s", ts, msg.From, newNick))
|
|
|
|
case "NOTICE":
|
|
lines := msg.BodyLines()
|
|
text := strings.Join(lines, " ")
|
|
a.ui.AddStatus(fmt.Sprintf("[gray]%s [magenta]--%s-- %s", ts, msg.From, text))
|
|
|
|
case "TOPIC":
|
|
lines := msg.BodyLines()
|
|
|
|
text := strings.Join(lines, " ")
|
|
if msg.To != "" {
|
|
a.ui.AddLine(msg.To, fmt.Sprintf("[gray]%s [cyan]*** %s set topic: %s", ts, msg.From, text))
|
|
}
|
|
|
|
default:
|
|
// Numeric replies and other messages → status window.
|
|
lines := msg.BodyLines()
|
|
|
|
text := strings.Join(lines, " ")
|
|
if text != "" {
|
|
a.ui.AddStatus(fmt.Sprintf("[gray]%s [white][%s] %s", ts, msg.Command, text))
|
|
}
|
|
}
|
|
}
|