sneak/chat
1
0
Fork 0
Code Issues 15 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: sneak:15caf5c8d2b63d3c40c93ffe0b563d63a5b0d45a
Branches Tags
sneak:main sneak:fix/29-split-dockerfile sneak:feature/mvp-1.0 sneak:fix/dockerfile-golangci-lint-v2-module-path sneak:fix/golangci-lint-sha-13 sneak:ci/make-check sneak:fix/main-lint-issues sneak:feature/web-client sneak:feature/database-schema sneak:fix/review-feedback sneak:fix/agents-md-workflow
..
compare: sneak:c65c9bbe5a1339c3cba9bd704970be22f95eb741
Branches Tags
sneak:main sneak:fix/29-split-dockerfile sneak:feature/mvp-1.0 sneak:fix/dockerfile-golangci-lint-v2-module-path sneak:fix/golangci-lint-sha-13 sneak:ci/make-check sneak:fix/main-lint-issues sneak:feature/web-client sneak:feature/database-schema sneak:fix/review-feedback sneak:fix/agents-md-workflow

1 Commits
15caf5c8d2 ... c65c9bbe5a

Author SHA1 Message Date
clawbot
c65c9bbe5a fix: resolve typecheck errors by removing duplicate db methods and updating handlers to use models-based API 2026-02-20 02:57:16 -08:00
13 changed files with 780 additions and 1229 deletions
Expand all files Collapse all files

167
cmd/chat-cli/api/client.go
View File

@@ -1,31 +1,15 @@
// Package chatapi provides a client for the chat server's HTTP API.
package chatapi
package api
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strconv"
"time"
)
const (
httpClientTimeout = 30
httpErrorMinCode = 400
pollExtraTimeout = 5
)
// ErrHTTPError is returned when the server responds with an error status.
var ErrHTTPError = errors.New("HTTP error")
// ErrUnexpectedFormat is returned when a response has an unexpected structure.
var ErrUnexpectedFormat = errors.New("unexpected format")
// Client wraps HTTP calls to the chat server API.
type Client struct {
BaseURL string
@@ -38,27 +22,59 @@ func NewClient(baseURL string) *Client {
return &Client{
BaseURL: baseURL,
HTTPClient: &http.Client{
Timeout: httpClientTimeout * time.Second,
Timeout: 30 * time.Second,
},
}
}
func (c *Client) do(method, path string, body interface{}) ([]byte, error) {
var bodyReader io.Reader
if body != nil {
data, err := json.Marshal(body)
if err != nil {
return nil, fmt.Errorf("marshal: %w", err)
}
bodyReader = bytes.NewReader(data)
}
req, err := http.NewRequest(method, c.BaseURL+path, bodyReader)
if err != nil {
return nil, fmt.Errorf("request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
if c.Token != "" {
req.Header.Set("Authorization", "Bearer "+c.Token)
}
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, fmt.Errorf("http: %w", err)
}
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("read body: %w", err)
}
if resp.StatusCode >= 400 {
return data, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(data))
}
return data, nil
}
// CreateSession creates a new session on the server.
func (c *Client) CreateSession(nick string) (*SessionResponse, error) {
data, err := c.do("POST", "/api/v1/session", &SessionRequest{Nick: nick})
if err != nil {
return nil, err
}
var resp SessionResponse
err = json.Unmarshal(data, &resp)
if err != nil {
if err := json.Unmarshal(data, &resp); err != nil {
return nil, fmt.Errorf("decode session: %w", err)
}
c.Token = resp.Token
return &resp, nil
}
@@ -68,77 +84,64 @@ func (c *Client) GetState() (*StateResponse, error) {
if err != nil {
return nil, err
}
var resp StateResponse
err = json.Unmarshal(data, &resp)
if err != nil {
if err := json.Unmarshal(data, &resp); err != nil {
return nil, fmt.Errorf("decode state: %w", err)
}
return &resp, nil
}
// SendMessage sends a message (any IRC command).
func (c *Client) SendMessage(msg *Message) error {
_, err := c.do("POST", "/api/v1/messages", msg)
return err
}
// PollMessages long-polls for new messages.
func (c *Client) PollMessages(afterID string, timeout int) ([]Message, error) {
// Use a longer HTTP timeout than the server long-poll timeout.
client := &http.Client{Timeout: time.Duration(timeout+pollExtraTimeout) * time.Second}
client := &http.Client{Timeout: time.Duration(timeout+5) * time.Second}
params := url.Values{}
if afterID != "" {
params.Set("after", afterID)
}
params.Set("timeout", strconv.Itoa(timeout))
params.Set("timeout", fmt.Sprintf("%d", timeout))
path := "/api/v1/messages"
if len(params) > 0 {
path += "?" + params.Encode()
}
req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, c.BaseURL+path, nil)
req, err := http.NewRequest("GET", c.BaseURL+path, nil)
if err != nil {
return nil, err
}
req.Header.Set("Authorization", "Bearer "+c.Token)
resp, err := client.Do(req) //nolint:gosec // URL is constructed from trusted base URL + API path, not user-tainted
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer func() { _ = resp.Body.Close() }()
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
if resp.StatusCode >= httpErrorMinCode {
return nil, fmt.Errorf("%w: %d: %s", ErrHTTPError, resp.StatusCode, string(data))
if resp.StatusCode >= 400 {
return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(data))
}
// The server may return an array directly or wrapped.
var msgs []Message
err = json.Unmarshal(data, &msgs)
if err != nil {
if err := json.Unmarshal(data, &msgs); err != nil {
// Try wrapped format.
var wrapped MessagesResponse
err2 := json.Unmarshal(data, &wrapped)
if err2 != nil {
if err2 := json.Unmarshal(data, &wrapped); err2 != nil {
return nil, fmt.Errorf("decode messages: %w (raw: %s)", err, string(data))
}
msgs = wrapped.Messages
}
@@ -161,14 +164,10 @@ func (c *Client) ListChannels() ([]Channel, error) {
if err != nil {
return nil, err
}
var channels []Channel
err = json.Unmarshal(data, &channels)
if err != nil {
if err := json.Unmarshal(data, &channels); err != nil {
return nil, err
}
return channels, nil
}
@@ -178,23 +177,16 @@ func (c *Client) GetMembers(channel string) ([]string, error) {
if err != nil {
return nil, err
}
var members []string
err = json.Unmarshal(data, &members)
if err != nil {
if err := json.Unmarshal(data, &members); err != nil {
// Try object format.
var obj map[string]any
err2 := json.Unmarshal(data, &obj)
if err2 != nil {
var obj map[string]interface{}
if err2 := json.Unmarshal(data, &obj); err2 != nil {
return nil, err
}
// Extract member names from whatever format.
return nil, fmt.Errorf("%w: members: %s", ErrUnexpectedFormat, string(data))
return nil, fmt.Errorf("unexpected members format: %s", string(data))
}
return members, nil
}
@@ -204,56 +196,9 @@ func (c *Client) GetServerInfo() (*ServerInfo, error) {
if err != nil {
return nil, err
}
var info ServerInfo
err = json.Unmarshal(data, &info)
if err != nil {
if err := json.Unmarshal(data, &info); err != nil {
return nil, err
}
return &info, nil
}
func (c *Client) do(method, path string, body any) ([]byte, error) {
var bodyReader io.Reader
if body != nil {
data, err := json.Marshal(body)
if err != nil {
return nil, fmt.Errorf("marshal: %w", err)
}
bodyReader = bytes.NewReader(data)
}
req, err := http.NewRequestWithContext(context.Background(), method, c.BaseURL+path, bodyReader)
if err != nil {
return nil, fmt.Errorf("request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
if c.Token != "" {
req.Header.Set("Authorization", "Bearer "+c.Token)
}
//nolint:gosec // URL built from trusted base + API path
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, fmt.Errorf("http: %w", err)
}
defer func() { _ = resp.Body.Close() }()
data, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("read body: %w", err)
}
if resp.StatusCode >= httpErrorMinCode {
return data, fmt.Errorf("%w: %d: %s", ErrHTTPError, resp.StatusCode, string(data))
}
return data, nil
}

33
cmd/chat-cli/api/types.go
View File

@@ -1,4 +1,4 @@
package chatapi
package api
import "time"
@@ -9,44 +9,42 @@ type SessionRequest struct {
// SessionResponse is the response from POST /api/v1/session.
type SessionResponse struct {
SessionID string `json:"sessionId"`
ClientID string `json:"clientId"`
SessionID string `json:"session_id"`
ClientID string `json:"client_id"`
Nick string `json:"nick"`
Token string `json:"token"`
}
// StateResponse is the response from GET /api/v1/state.
type StateResponse struct {
SessionID string `json:"sessionId"`
ClientID string `json:"clientId"`
SessionID string `json:"session_id"`
ClientID string `json:"client_id"`
Nick string `json:"nick"`
Channels []string `json:"channels"`
}
// Message represents a chat message envelope.
type Message struct {
Command string `json:"command"`
From string `json:"from,omitempty"`
To string `json:"to,omitempty"`
Params []string `json:"params,omitempty"`
Body any `json:"body,omitempty"`
ID string `json:"id,omitempty"`
TS string `json:"ts,omitempty"`
Meta any `json:"meta,omitempty"`
Command string `json:"command"`
From string `json:"from,omitempty"`
To string `json:"to,omitempty"`
Params []string `json:"params,omitempty"`
Body interface{} `json:"body,omitempty"`
ID string `json:"id,omitempty"`
TS string `json:"ts,omitempty"`
Meta interface{} `json:"meta,omitempty"`
}
// BodyLines returns the body as a slice of strings (for text messages).
func (m *Message) BodyLines() []string {
switch v := m.Body.(type) {
case []any:
case []interface{}:
lines := make([]string, 0, len(v))
for _, item := range v {
if s, ok := item.(string); ok {
lines = append(lines, s)
}
}
return lines
case []string:
return v
@@ -60,7 +58,7 @@ type Channel struct {
Name string `json:"name"`
Topic string `json:"topic"`
Members int `json:"members"`
CreatedAt string `json:"createdAt"`
CreatedAt string `json:"created_at"`
}
// ServerInfo is the response from GET /api/v1/server.
@@ -81,6 +79,5 @@ func (m *Message) ParseTS() time.Time {
if err != nil {
return time.Now()
}
return t
}

376
cmd/chat-cli/main.go
View File

@@ -1,4 +1,3 @@
// Package main provides a terminal-based IRC-style chat client.
package main
import (
@@ -11,18 +10,10 @@ import (
"git.eeqj.de/sneak/chat/cmd/chat-cli/api"
)
const (
maxNickLen = 32
pollTimeoutSec = 15
pollRetrySec = 2
splitNParts = 2
commandSplitArgs = 2
)
// App holds the application state.
type App struct {
ui *UI
client *chatapi.Client
client *api.Client
mu sync.Mutex
nick string
@@ -44,8 +35,7 @@ func main() {
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 {
if err := app.ui.Run(); err != nil {
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
os.Exit(1)
}
@@ -54,7 +44,6 @@ func main() {
func (a *App) handleInput(text string) {
if strings.HasPrefix(text, "/") {
a.handleCommand(text)
return
}
@@ -66,95 +55,74 @@ func (a *App) handleInput(text string) {
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(&chatapi.Message{
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) {
a.dispatchCommand(text)
}
func (a *App) dispatchCommand(text string) {
parts := strings.SplitN(text, " ", splitNParts)
parts := strings.SplitN(text, " ", 2)
cmd := strings.ToLower(parts[0])
args := ""
if len(parts) > 1 {
args = parts[1]
}
a.execCommand(cmd, args)
}
func (a *App) execCommand(cmd, args string) {
commands := a.commandMap()
handler, ok := commands[cmd]
if !ok {
a.ui.AddStatus("[red]Unknown command: " + cmd)
return
}
handler(args)
}
func (a *App) commandMap() map[string]func(string) {
noArgs := func(fn func()) func(string) {
return func(_ string) { fn() }
}
return map[string]func(string){
"/connect": a.cmdConnect,
"/nick": a.cmdNick,
"/join": a.cmdJoin,
"/part": a.cmdPart,
"/msg": a.cmdMsg,
"/query": a.cmdQuery,
"/topic": a.cmdTopic,
"/names": noArgs(a.cmdNames),
"/list": noArgs(a.cmdList),
"/window": a.cmdWindow,
"/w": a.cmdWindow,
"/quit": noArgs(a.cmdQuit),
"/help": noArgs(a.cmdHelp),
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(fmt.Sprintf("[red]Unknown command: %s", 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))
@@ -163,12 +131,10 @@ func (a *App) cmdConnect(serverURL string) {
nick := a.nick
a.mu.Unlock()
client := chatapi.NewClient(serverURL)
client := api.NewClient(serverURL)
resp, err := client.CreateSession(nick)
if err != nil {
a.ui.AddStatus(fmt.Sprintf("[red]Connection failed: %v", err))
return
}
@@ -184,17 +150,14 @@ func (a *App) cmdConnect(serverURL string) {
// 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()
@@ -203,19 +166,16 @@ func (a *App) cmdNick(nick string) {
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(&chatapi.Message{
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
}
@@ -223,18 +183,15 @@ func (a *App) cmdNick(nick string) {
a.nick = nick
target := a.target
a.mu.Unlock()
a.ui.SetStatus(nick, target, "connected")
a.ui.AddStatus("Nick changed to " + nick)
a.ui.AddStatus(fmt.Sprintf("Nick changed to %s", nick))
}
func (a *App) cmdJoin(channel string) {
if channel == "" {
a.ui.AddStatus("[red]Usage: /join #channel")
return
}
if !strings.HasPrefix(channel, "#") {
channel = "#" + channel
}
@@ -242,17 +199,14 @@ func (a *App) cmdJoin(channel string) {
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
}
@@ -262,47 +216,39 @@ func (a *App) cmdJoin(channel string) {
a.mu.Unlock()
a.ui.SwitchToBuffer(channel)
a.ui.AddLine(channel, "[yellow]*** Joined "+channel)
a.ui.AddLine(channel, fmt.Sprintf("[yellow]*** Joined %s", 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.ui.AddLine(channel, fmt.Sprintf("[yellow]*** Left %s", channel))
a.mu.Lock()
if a.target == channel {
a.target = ""
}
nick := a.nick
a.mu.Unlock()
@@ -311,35 +257,29 @@ func (a *App) cmdPart(channel string) {
}
func (a *App) cmdMsg(args string) {
parts := strings.SplitN(args, " ", commandSplitArgs)
if len(parts) < commandSplitArgs {
parts := strings.SplitN(args, " ", 2)
if len(parts) < 2 {
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(&chatapi.Message{
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
}
@@ -350,7 +290,6 @@ func (a *App) cmdMsg(args string) {
func (a *App) cmdQuery(nick string) {
if nick == "" {
a.ui.AddStatus("[red]Usage: /query <nick>")
return
}
@@ -371,30 +310,26 @@ func (a *App) cmdTopic(args string) {
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(&chatapi.Message{
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(&chatapi.Message{
err := a.client.SendMessage(&api.Message{
Command: "TOPIC",
To: target,
Body: []string{args},
@@ -412,20 +347,16 @@ func (a *App) cmdNames() {
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
}
@@ -439,51 +370,46 @@ func (a *App) cmdList() {
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)
fmt.Sscanf(args, "%d", &n)
a.ui.SwitchBuffer(n)
a.mu.Lock()
if n < a.ui.BufferCount() && n >= 0 {
// Update target to the buffer name.
// Needs to be done carefully.
}
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")
@@ -493,15 +419,12 @@ func (a *App) cmdWindow(args string) {
func (a *App) cmdQuit() {
a.mu.Lock()
if a.connected && a.client != nil {
_ = a.client.SendMessage(&chatapi.Message{Command: "QUIT"})
_ = a.client.SendMessage(&api.Message{Command: "QUIT"})
}
if a.stopPoll != nil {
close(a.stopPoll)
}
a.mu.Unlock()
a.ui.Stop()
}
@@ -523,7 +446,6 @@ func (a *App) cmdHelp() {
" /help — This help",
" Plain text sends to current target.",
}
for _, line := range help {
a.ui.AddStatus(line)
}
@@ -547,17 +469,15 @@ func (a *App) pollLoop() {
return
}
msgs, err := client.PollMessages(lastID, pollTimeoutSec)
msgs, err := client.PollMessages(lastID, 15)
if err != nil {
// Transient error — retry after delay.
time.Sleep(pollRetrySec * time.Second)
time.Sleep(2 * time.Second)
continue
}
for _, msg := range msgs {
a.handleServerMessage(&msg)
if msg.ID != "" {
a.mu.Lock()
a.lastMsgID = msg.ID
@@ -567,8 +487,14 @@ func (a *App) pollLoop() {
}
}
func (a *App) handleServerMessage(msg *chatapi.Message) {
ts := a.formatMessageTS(msg)
func (a *App) handleServerMessage(msg *api.Message) {
ts := ""
if msg.TS != "" {
t := msg.ParseTS()
ts = t.Local().Format("15:04")
} else {
ts = time.Now().Format("15:04")
}
a.mu.Lock()
myNick := a.nick
@@ -576,131 +502,79 @@ func (a *App) handleServerMessage(msg *chatapi.Message) {
switch msg.Command {
case "PRIVMSG":
a.handlePrivmsg(msg, ts, myNick)
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":
a.handleJoinMsg(msg, ts)
target := msg.To
if target != "" {
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [yellow]*** %s has joined %s", ts, msg.From, target))
}
case "PART":
a.handlePartMsg(msg, ts)
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":
a.handleQuitMsg(msg, ts)
case "NICK":
a.handleNickMsg(msg, ts, myNick)
case "NOTICE":
a.handleNoticeMsg(msg, ts)
case "TOPIC":
a.handleTopicMsg(msg, ts)
default:
a.handleDefaultMsg(msg, ts)
}
}
func (a *App) formatMessageTS(msg *chatapi.Message) string {
if msg.TS != "" {
t := msg.ParseTS()
return t.Local().Format("15:04") //nolint:gosmopolitan // Local time display is intentional for UI
}
return time.Now().Format("15:04")
}
func (a *App) handlePrivmsg(msg *chatapi.Message, ts, myNick string) {
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))
}
func (a *App) handleJoinMsg(msg *chatapi.Message, ts string) {
target := msg.To
if target != "" {
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [yellow]*** %s has joined %s", ts, msg.From, target))
}
}
func (a *App) handlePartMsg(msg *chatapi.Message, ts string) {
target := msg.To
lines := msg.BodyLines()
reason := strings.Join(lines, " ")
if target != "" {
lines := msg.BodyLines()
reason := strings.Join(lines, " ")
if reason != "" {
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [yellow]*** %s has left %s (%s)", ts, msg.From, target, reason))
a.ui.AddStatus(fmt.Sprintf("[gray]%s [yellow]*** %s has quit (%s)", ts, msg.From, reason))
} else {
a.ui.AddLine(target, fmt.Sprintf("[gray]%s [yellow]*** %s has left %s", ts, msg.From, target))
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))
}
}
}
func (a *App) handleQuitMsg(msg *chatapi.Message, ts string) {
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))
}
}
func (a *App) handleNickMsg(msg *chatapi.Message, ts, myNick string) {
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))
}
func (a *App) handleNoticeMsg(msg *chatapi.Message, ts string) {
lines := msg.BodyLines()
text := strings.Join(lines, " ")
a.ui.AddStatus(fmt.Sprintf("[gray]%s [magenta]--%s-- %s", ts, msg.From, text))
}
func (a *App) handleTopicMsg(msg *chatapi.Message, ts string) {
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))
}
}
func (a *App) handleDefaultMsg(msg *chatapi.Message, ts string) {
lines := msg.BodyLines()
text := strings.Join(lines, " ")
if text != "" {
a.ui.AddStatus(fmt.Sprintf("[gray]%s [white][%s] %s", ts, msg.Command, text))
}
}

211
cmd/chat-cli/ui.go
View File

@@ -39,9 +39,60 @@ func NewUI() *UI {
},
}
ui.setupWidgets()
ui.setupInputCapture()
ui.setupLayout()
// Message area.
ui.messages = tview.NewTextView().
SetDynamicColors(true).
SetScrollable(true).
SetWordWrap(true).
SetChangedFunc(func() {
ui.app.Draw()
})
ui.messages.SetBorder(false)
// Status bar.
ui.statusBar = tview.NewTextView().
SetDynamicColors(true)
ui.statusBar.SetBackgroundColor(tcell.ColorNavy)
ui.statusBar.SetTextColor(tcell.ColorWhite)
// Input field.
ui.input = tview.NewInputField().
SetFieldBackgroundColor(tcell.ColorBlack).
SetFieldTextColor(tcell.ColorWhite)
ui.input.SetDoneFunc(func(key tcell.Key) {
if key == tcell.KeyEnter {
text := ui.input.GetText()
if text == "" {
return
}
ui.input.SetText("")
if ui.onInput != nil {
ui.onInput(text)
}
}
})
// Capture Alt+N for window switching.
ui.app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
if event.Modifiers()&tcell.ModAlt != 0 {
r := event.Rune()
if r >= '0' && r <= '9' {
idx := int(r - '0')
ui.SwitchBuffer(idx)
return nil
}
}
return event
})
// Layout: messages on top, status bar, input at bottom.
ui.layout = tview.NewFlex().SetDirection(tview.FlexRow).
AddItem(ui.messages, 0, 1, false).
AddItem(ui.statusBar, 1, 0, false).
AddItem(ui.input, 1, 0, true)
ui.app.SetRoot(ui.layout, true)
ui.app.SetFocus(ui.input)
return ui
}
@@ -70,13 +121,12 @@ func (ui *UI) AddLine(bufferName string, line string) {
// Mark unread if not currently viewing this buffer.
if ui.buffers[ui.currentBuffer] != buf {
buf.Unread++
ui.refreshStatus()
}
// If viewing this buffer, append to display.
if ui.buffers[ui.currentBuffer] == buf {
_, _ = fmt.Fprintln(ui.messages, line)
fmt.Fprintln(ui.messages, line)
}
})
}
@@ -93,18 +143,13 @@ func (ui *UI) SwitchBuffer(n int) {
if n < 0 || n >= len(ui.buffers) {
return
}
ui.currentBuffer = n
buf := ui.buffers[n]
buf.Unread = 0
ui.messages.Clear()
for _, line := range buf.Lines {
_, _ = fmt.Fprintln(ui.messages, line)
fmt.Fprintln(ui.messages, line)
}
ui.messages.ScrollToEnd()
ui.refreshStatus()
})
@@ -114,23 +159,17 @@ func (ui *UI) SwitchBuffer(n int) {
func (ui *UI) SwitchToBuffer(name string) {
ui.app.QueueUpdateDraw(func() {
buf := ui.getOrCreateBuffer(name)
for i, b := range ui.buffers {
if b == buf {
ui.currentBuffer = i
break
}
}
buf.Unread = 0
ui.messages.Clear()
for _, line := range buf.Lines {
_, _ = fmt.Fprintln(ui.messages, line)
fmt.Fprintln(ui.messages, line)
}
ui.messages.ScrollToEnd()
ui.refreshStatus()
})
@@ -143,6 +182,41 @@ func (ui *UI) SetStatus(nick, target, connStatus string) {
})
}
func (ui *UI) refreshStatus() {
// Will be called from the main goroutine via QueueUpdateDraw parent.
// Rebuild status from app state — caller must provide context.
}
func (ui *UI) refreshStatusWith(nick, target, connStatus string) {
var unreadParts []string
for i, buf := range ui.buffers {
if buf.Unread > 0 {
unreadParts = append(unreadParts, fmt.Sprintf("%d:%s(%d)", i, buf.Name, buf.Unread))
}
}
unread := ""
if len(unreadParts) > 0 {
unread = " [Act: " + strings.Join(unreadParts, ",") + "]"
}
bufInfo := fmt.Sprintf("[%d:%s]", ui.currentBuffer, ui.buffers[ui.currentBuffer].Name)
ui.statusBar.Clear()
fmt.Fprintf(ui.statusBar, " [%s] %s %s %s%s",
connStatus, nick, bufInfo, target, unread)
}
func (ui *UI) getOrCreateBuffer(name string) *Buffer {
for _, buf := range ui.buffers {
if buf.Name == name {
return buf
}
}
buf := &Buffer{Name: name}
ui.buffers = append(ui.buffers, buf)
return buf
}
// BufferCount returns the number of buffers.
func (ui *UI) BufferCount() int {
return len(ui.buffers)
@@ -155,106 +229,5 @@ func (ui *UI) BufferIndex(name string) int {
return i
}
}
return -1
}
func (ui *UI) setupWidgets() {
ui.messages = tview.NewTextView().
SetDynamicColors(true).
SetScrollable(true).
SetWordWrap(true).
SetChangedFunc(func() {
ui.app.Draw()
})
ui.messages.SetBorder(false)
ui.statusBar = tview.NewTextView().
SetDynamicColors(true)
ui.statusBar.SetBackgroundColor(tcell.ColorNavy)
ui.statusBar.SetTextColor(tcell.ColorWhite)
ui.input = tview.NewInputField().
SetFieldBackgroundColor(tcell.ColorBlack).
SetFieldTextColor(tcell.ColorWhite)
ui.input.SetDoneFunc(func(key tcell.Key) {
if key == tcell.KeyEnter {
text := ui.input.GetText()
if text == "" {
return
}
ui.input.SetText("")
if ui.onInput != nil {
ui.onInput(text)
}
}
})
}
func (ui *UI) setupInputCapture() {
ui.app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
if event.Modifiers()&tcell.ModAlt != 0 {
r := event.Rune()
if r >= '0' && r <= '9' {
idx := int(r - '0')
ui.SwitchBuffer(idx)
return nil
}
}
return event
})
}
func (ui *UI) setupLayout() {
ui.layout = tview.NewFlex().SetDirection(tview.FlexRow).
AddItem(ui.messages, 0, 1, false).
AddItem(ui.statusBar, 1, 0, false).
AddItem(ui.input, 1, 0, true)
ui.app.SetRoot(ui.layout, true)
ui.app.SetFocus(ui.input)
}
func (ui *UI) refreshStatus() {
// Will be called from the main goroutine via QueueUpdateDraw parent.
// Rebuild status from app state — caller must provide context.
}
func (ui *UI) refreshStatusWith(nick, target, connStatus string) {
var unreadParts []string
for i, buf := range ui.buffers {
if buf.Unread > 0 {
unreadParts = append(unreadParts, fmt.Sprintf("%d:%s(%d)", i, buf.Name, buf.Unread))
}
}
unread := ""
if len(unreadParts) > 0 {
unread = " [Act: " + strings.Join(unreadParts, ",") + "]"
}
bufInfo := fmt.Sprintf("[%d:%s]", ui.currentBuffer, ui.buffers[ui.currentBuffer].Name)
ui.statusBar.Clear()
_, _ = fmt.Fprintf(ui.statusBar, " [%s] %s %s %s%s",
connStatus, nick, bufInfo, target, unread)
}
func (ui *UI) getOrCreateBuffer(name string) *Buffer {
for _, buf := range ui.buffers {
if buf.Name == name {
return buf
}
}
buf := &Buffer{Name: name}
ui.buffers = append(ui.buffers, buf)
return buf
}

98
internal/db/db.go
View File

@@ -88,10 +88,8 @@ func NewTest(dsn string) (*Database, error) {
}
// Item 9: Enable foreign keys
_, err = d.ExecContext(context.Background(), "PRAGMA foreign_keys = ON")
if err != nil {
if _, err := d.Exec("PRAGMA foreign_keys = ON"); err != nil {
_ = d.Close()
return nil, fmt.Errorf("enable foreign keys: %w", err)
}
@@ -221,7 +219,6 @@ func (s *Database) DeleteAuthToken(
_, err := s.db.ExecContext(ctx,
`DELETE FROM auth_tokens WHERE token = ?`, token,
)
return err
}
@@ -234,7 +231,6 @@ func (s *Database) UpdateUserLastSeen(
`UPDATE users SET last_seen_at = CURRENT_TIMESTAMP WHERE id = ?`,
userID,
)
return err
}
@@ -398,7 +394,6 @@ func (s *Database) DequeueMessages(
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
entries := []*models.MessageQueueEntry{}
@@ -428,14 +423,14 @@ func (s *Database) AckMessages(
}
placeholders := make([]string, len(entryIDs))
args := make([]any, len(entryIDs))
args := make([]interface{}, len(entryIDs))
for i, id := range entryIDs {
placeholders[i] = "?"
args[i] = id
}
query := fmt.Sprintf( //nolint:gosec // G201: placeholders are literal "?" strings, not user input
query := fmt.Sprintf(
"DELETE FROM message_queue WHERE id IN (%s)",
strings.Join(placeholders, ","),
)
@@ -554,8 +549,7 @@ func (s *Database) connect(ctx context.Context) error {
s.log.Info("database connected")
// Item 9: Enable foreign keys on every connection
_, err = s.db.ExecContext(ctx, "PRAGMA foreign_keys = ON")
if err != nil {
if _, err := s.db.ExecContext(ctx, "PRAGMA foreign_keys = ON"); err != nil {
return fmt.Errorf("enable foreign keys: %w", err)
}
@@ -677,56 +671,46 @@ func (s *Database) applyMigrations(
continue
}
err = s.applySingleMigration(ctx, m)
s.log.Info(
"applying migration",
"version", m.version, "name", m.name,
)
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
return fmt.Errorf(
"begin tx for migration %d: %w", m.version, err,
)
}
_, err = tx.ExecContext(ctx, m.sql)
if err != nil {
_ = tx.Rollback()
return fmt.Errorf(
"apply migration %d (%s): %w",
m.version, m.name, err,
)
}
_, err = tx.ExecContext(ctx,
"INSERT INTO schema_migrations (version) VALUES (?)",
m.version,
)
if err != nil {
_ = tx.Rollback()
return fmt.Errorf(
"record migration %d: %w", m.version, err,
)
}
if err := tx.Commit(); err != nil {
return fmt.Errorf(
"commit migration %d: %w", m.version, err,
)
}
}
return nil
}
func (s *Database) applySingleMigration(ctx context.Context, m migration) error {
s.log.Info(
"applying migration",
"version", m.version, "name", m.name,
)
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf(
"begin tx for migration %d: %w", m.version, err,
)
}
_, err = tx.ExecContext(ctx, m.sql)
if err != nil {
_ = tx.Rollback()
return fmt.Errorf(
"apply migration %d (%s): %w",
m.version, m.name, err,
)
}
_, err = tx.ExecContext(ctx,
"INSERT INTO schema_migrations (version) VALUES (?)",
m.version,
)
if err != nil {
_ = tx.Rollback()
return fmt.Errorf(
"record migration %d: %w", m.version, err,
)
}
err = tx.Commit()
if err != nil {
return fmt.Errorf(
"commit migration %d: %w", m.version, err,
)
}
return nil
}

545
internal/db/queries.go
View File

@@ -2,68 +2,13 @@ package db
import (
"context"
"crypto/rand"
"database/sql"
"encoding/hex"
"fmt"
"time"
)
const tokenBytes = 32
func generateToken() string {
b := make([]byte, tokenBytes)
_, _ = rand.Read(b)
return hex.EncodeToString(b)
}
// CreateSimpleUser registers a new user with the given nick and returns the user ID and token.
func (s *Database) CreateSimpleUser(ctx context.Context, nick string) (int64, string, error) {
token := generateToken()
now := time.Now()
res, err := s.db.ExecContext(ctx,
"INSERT INTO users (nick, token, created_at, last_seen) VALUES (?, ?, ?, ?)",
nick, token, now, now)
if err != nil {
return 0, "", fmt.Errorf("create user: %w", err)
}
id, _ := res.LastInsertId()
return id, token, nil
}
// LookupUserByToken returns user id and nick for a given auth token.
func (s *Database) LookupUserByToken(ctx context.Context, token string) (int64, string, error) {
var id int64
var nick string
err := s.db.QueryRowContext(ctx, "SELECT id, nick FROM users WHERE token = ?", token).Scan(&id, &nick)
if err != nil {
return 0, "", err
}
// Update last_seen
_, _ = s.db.ExecContext(ctx, "UPDATE users SET last_seen = ? WHERE id = ?", time.Now(), id)
return id, nick, nil
}
// LookupUserByNick returns user id for a given nick.
func (s *Database) LookupUserByNick(ctx context.Context, nick string) (int64, error) {
var id int64
err := s.db.QueryRowContext(ctx, "SELECT id FROM users WHERE nick = ?", nick).Scan(&id)
return id, err
}
// GetOrCreateChannel returns the channel id, creating it if needed.
func (s *Database) GetOrCreateChannel(ctx context.Context, name string) (int64, error) {
var id int64
func (s *Database) GetOrCreateChannel(ctx context.Context, name string) (string, error) {
var id string
err := s.db.QueryRowContext(ctx, "SELECT id FROM channels WHERE name = ?", name).Scan(&id)
if err == nil {
@@ -71,30 +16,29 @@ func (s *Database) GetOrCreateChannel(ctx context.Context, name string) (int64,
}
now := time.Now()
id = fmt.Sprintf("ch-%d", now.UnixNano())
res, err := s.db.ExecContext(ctx,
"INSERT INTO channels (name, created_at, updated_at) VALUES (?, ?, ?)",
name, now, now)
_, err = s.db.ExecContext(ctx,
"INSERT INTO channels (id, name, topic, modes, created_at, updated_at) VALUES (?, ?, '', '', ?, ?)",
id, name, now, now)
if err != nil {
return 0, fmt.Errorf("create channel: %w", err)
return "", fmt.Errorf("create channel: %w", err)
}
id, _ = res.LastInsertId()
return id, nil
}
// JoinChannel adds a user to a channel.
func (s *Database) JoinChannel(ctx context.Context, channelID, userID int64) error {
func (s *Database) JoinChannel(ctx context.Context, channelID, userID string) error {
_, err := s.db.ExecContext(ctx,
"INSERT OR IGNORE INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)",
"INSERT OR IGNORE INTO channel_members (channel_id, user_id, modes, joined_at) VALUES (?, ?, '', ?)",
channelID, userID, time.Now())
return err
}
// PartChannel removes a user from a channel.
func (s *Database) PartChannel(ctx context.Context, channelID, userID int64) error {
func (s *Database) PartChannel(ctx context.Context, channelID, userID string) error {
_, err := s.db.ExecContext(ctx,
"DELETE FROM channel_members WHERE channel_id = ? AND user_id = ?",
channelID, userID)
@@ -102,15 +46,8 @@ func (s *Database) PartChannel(ctx context.Context, channelID, userID int64) err
return err
}
// ChannelInfo is a lightweight channel representation.
type ChannelInfo struct {
ID int64 `json:"id"`
Name string `json:"name"`
Topic string `json:"topic"`
}
// ListChannels returns all channels the user has joined.
func (s *Database) ListChannels(ctx context.Context, userID int64) ([]ChannelInfo, error) {
func (s *Database) ListChannels(ctx context.Context, userID string) ([]ChannelInfo, error) {
rows, err := s.db.QueryContext(ctx,
`SELECT c.id, c.name, c.topic FROM channels c
INNER JOIN channel_members cm ON cm.channel_id = c.id
@@ -119,20 +56,33 @@ func (s *Database) ListChannels(ctx context.Context, userID int64) ([]ChannelInf
return nil, err
}
return scanChannelInfoRows(rows)
defer func() { _ = rows.Close() }()
channels := []ChannelInfo{}
for rows.Next() {
var ch ChannelInfo
if err := rows.Scan(&ch.ID, &ch.Name, &ch.Topic); err != nil {
return nil, err
}
channels = append(channels, ch)
}
return channels, rows.Err()
}
// MemberInfo represents a channel member.
type MemberInfo struct {
ID int64 `json:"id"`
Nick string `json:"nick"`
LastSeen time.Time `json:"lastSeen"`
// ChannelInfo is a lightweight channel representation.
type ChannelInfo struct {
ID string `json:"id"`
Name string `json:"name"`
Topic string `json:"topic"`
}
// ChannelMembers returns all members of a channel.
func (s *Database) ChannelMembers(ctx context.Context, channelID int64) ([]MemberInfo, error) {
func (s *Database) ChannelMembers(ctx context.Context, channelID string) ([]MemberInfo, error) {
rows, err := s.db.QueryContext(ctx,
`SELECT u.id, u.nick, u.last_seen FROM users u
`SELECT u.id, u.nick, u.last_seen_at FROM users u
INNER JOIN channel_members cm ON cm.user_id = u.id
WHERE cm.channel_id = ? ORDER BY u.nick`, channelID)
if err != nil {
@@ -141,34 +91,30 @@ func (s *Database) ChannelMembers(ctx context.Context, channelID int64) ([]Membe
defer func() { _ = rows.Close() }()
var members []MemberInfo
members := []MemberInfo{}
for rows.Next() {
var m MemberInfo
scanErr := rows.Scan(&m.ID, &m.Nick, &m.LastSeen)
if scanErr != nil {
return nil, scanErr
if err := rows.Scan(&m.ID, &m.Nick, &m.LastSeen); err != nil {
return nil, err
}
members = append(members, m)
}
err = rows.Err()
if err != nil {
return nil, err
}
return members, rows.Err()
}
if members == nil {
members = []MemberInfo{}
}
return members, nil
// MemberInfo represents a channel member.
type MemberInfo struct {
ID string `json:"id"`
Nick string `json:"nick"`
LastSeen *time.Time `json:"lastSeen"`
}
// MessageInfo represents a chat message.
type MessageInfo struct {
ID int64 `json:"id"`
ID string `json:"id"`
Channel string `json:"channel,omitempty"`
Nick string `json:"nick"`
Content string `json:"content"`
@@ -177,163 +123,191 @@ type MessageInfo struct {
CreatedAt time.Time `json:"createdAt"`
}
const defaultMessageLimit = 50
const defaultPollLimit = 100
// GetMessages returns messages for a channel, optionally after a given ID.
func (s *Database) GetMessages(
ctx context.Context, channelID int64, afterID int64, limit int,
) ([]MessageInfo, error) {
if limit <= 0 {
limit = defaultMessageLimit
}
rows, err := s.db.QueryContext(ctx,
`SELECT m.id, c.name, u.nick, m.content, m.created_at
FROM messages m
INNER JOIN users u ON u.id = m.user_id
INNER JOIN channels c ON c.id = m.channel_id
WHERE m.channel_id = ? AND m.is_dm = 0 AND m.id > ?
ORDER BY m.id ASC LIMIT ?`, channelID, afterID, limit)
if err != nil {
return nil, err
}
return scanChannelMessages(rows)
}
// SendMessage inserts a channel message.
func (s *Database) SendMessage(
ctx context.Context, channelID, userID int64, content string,
) (int64, error) {
res, err := s.db.ExecContext(ctx,
"INSERT INTO messages (channel_id, user_id, content, is_dm, created_at) VALUES (?, ?, ?, 0, ?)",
channelID, userID, content, time.Now())
func (s *Database) SendMessage(ctx context.Context, channelID, userID, nick, content string) (string, error) {
now := time.Now()
id := fmt.Sprintf("msg-%d", now.UnixNano())
_, err := s.db.ExecContext(ctx,
`INSERT INTO messages (id, ts, from_user_id, from_nick, target, type, body, meta, created_at)
VALUES (?, ?, ?, ?, ?, 'message', ?, '{}', ?)`,
id, now, userID, nick, channelID, content, now)
if err != nil {
return 0, err
return "", err
}
return res.LastInsertId()
return id, nil
}
// SendDM inserts a direct message.
func (s *Database) SendDM(
ctx context.Context, fromID, toID int64, content string,
) (int64, error) {
res, err := s.db.ExecContext(ctx,
"INSERT INTO messages (user_id, content, is_dm, dm_target_id, created_at) VALUES (?, ?, 1, ?, ?)",
fromID, content, toID, time.Now())
func (s *Database) SendDM(ctx context.Context, fromID, fromNick, toID, content string) (string, error) {
now := time.Now()
id := fmt.Sprintf("msg-%d", now.UnixNano())
_, err := s.db.ExecContext(ctx,
`INSERT INTO messages (id, ts, from_user_id, from_nick, target, type, body, meta, created_at)
VALUES (?, ?, ?, ?, ?, 'message', ?, '{}', ?)`,
id, now, fromID, fromNick, toID, content, now)
if err != nil {
return 0, err
return "", err
}
return res.LastInsertId()
return id, nil
}
// GetDMs returns direct messages between two users after a given ID.
func (s *Database) GetDMs(
ctx context.Context, userA, userB int64, afterID int64, limit int,
) ([]MessageInfo, error) {
// PollMessages returns all new messages for a user's joined channels, ordered by timestamp.
func (s *Database) PollMessages(ctx context.Context, userID string, afterTS string, limit int) ([]MessageInfo, error) {
if limit <= 0 {
limit = defaultMessageLimit
limit = 100
}
rows, err := s.db.QueryContext(ctx,
`SELECT m.id, u.nick, m.content, t.nick, m.created_at
`SELECT m.id, m.target, m.from_nick, m.body, m.created_at
FROM messages m
INNER JOIN users u ON u.id = m.user_id
INNER JOIN users t ON t.id = m.dm_target_id
WHERE m.is_dm = 1 AND m.id > ?
AND ((m.user_id = ? AND m.dm_target_id = ?) OR (m.user_id = ? AND m.dm_target_id = ?))
ORDER BY m.id ASC LIMIT ?`, afterID, userA, userB, userB, userA, limit)
if err != nil {
return nil, err
}
return scanDMMessages(rows)
}
// PollMessages returns all new messages (channel + DM) for a user after a given ID.
func (s *Database) PollMessages(
ctx context.Context, userID int64, afterID int64, limit int,
) ([]MessageInfo, error) {
if limit <= 0 {
limit = defaultPollLimit
}
rows, err := s.db.QueryContext(ctx,
`SELECT m.id, COALESCE(c.name, ''), u.nick, m.content, m.is_dm,
COALESCE(t.nick, ''), m.created_at
FROM messages m
INNER JOIN users u ON u.id = m.user_id
LEFT JOIN channels c ON c.id = m.channel_id
LEFT JOIN users t ON t.id = m.dm_target_id
WHERE m.id > ? AND (
(m.is_dm = 0 AND m.channel_id IN
(SELECT channel_id FROM channel_members WHERE user_id = ?))
OR (m.is_dm = 1 AND (m.user_id = ? OR m.dm_target_id = ?))
WHERE m.created_at > COALESCE(NULLIF(?, ''), '1970-01-01')
AND (
m.target IN (SELECT cm.channel_id FROM channel_members cm WHERE cm.user_id = ?)
OR m.target = ?
OR m.from_user_id = ?
)
ORDER BY m.id ASC LIMIT ?`, afterID, userID, userID, userID, limit)
ORDER BY m.created_at ASC LIMIT ?`,
afterTS, userID, userID, userID, limit)
if err != nil {
return nil, err
}
return scanPollMessages(rows)
defer func() { _ = rows.Close() }()
msgs := []MessageInfo{}
for rows.Next() {
var m MessageInfo
if err := rows.Scan(&m.ID, &m.Channel, &m.Nick, &m.Content, &m.CreatedAt); err != nil {
return nil, err
}
msgs = append(msgs, m)
}
return msgs, rows.Err()
}
// GetMessagesBefore returns channel messages before a given ID (for history scrollback).
func (s *Database) GetMessagesBefore(
ctx context.Context, channelID int64, beforeID int64, limit int,
) ([]MessageInfo, error) {
// GetMessagesBefore returns channel messages before a given timestamp (for history scrollback).
func (s *Database) GetMessagesBefore(ctx context.Context, target string, beforeTS string, limit int) ([]MessageInfo, error) {
if limit <= 0 {
limit = defaultMessageLimit
limit = 50
}
query, args := buildChannelHistoryQuery(channelID, beforeID, limit)
var rows interface {
Next() bool
Scan(dest ...interface{}) error
Close() error
Err() error
}
var err error
if beforeTS != "" {
rows, err = s.db.QueryContext(ctx,
`SELECT m.id, m.target, m.from_nick, m.body, m.created_at
FROM messages m
WHERE m.target = ? AND m.created_at < ?
ORDER BY m.created_at DESC LIMIT ?`,
target, beforeTS, limit)
} else {
rows, err = s.db.QueryContext(ctx,
`SELECT m.id, m.target, m.from_nick, m.body, m.created_at
FROM messages m
WHERE m.target = ?
ORDER BY m.created_at DESC LIMIT ?`,
target, limit)
}
rows, err := s.db.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
msgs, err := scanChannelMessages(rows)
if err != nil {
return nil, err
defer func() { _ = rows.Close() }()
msgs := []MessageInfo{}
for rows.Next() {
var m MessageInfo
if err := rows.Scan(&m.ID, &m.Channel, &m.Nick, &m.Content, &m.CreatedAt); err != nil {
return nil, err
}
msgs = append(msgs, m)
}
reverseMessages(msgs)
// Reverse to ascending order.
for i, j := 0, len(msgs)-1; i < j; i, j = i+1, j-1 {
msgs[i], msgs[j] = msgs[j], msgs[i]
}
return msgs, nil
return msgs, rows.Err()
}
// GetDMsBefore returns DMs between two users before a given ID (for history scrollback).
func (s *Database) GetDMsBefore(
ctx context.Context, userA, userB int64, beforeID int64, limit int,
) ([]MessageInfo, error) {
// GetDMsBefore returns DMs between two users before a given timestamp.
func (s *Database) GetDMsBefore(ctx context.Context, userA, userB string, beforeTS string, limit int) ([]MessageInfo, error) {
if limit <= 0 {
limit = defaultMessageLimit
limit = 50
}
query, args := buildDMHistoryQuery(userA, userB, beforeID, limit)
var rows interface {
Next() bool
Scan(dest ...interface{}) error
Close() error
Err() error
}
var err error
if beforeTS != "" {
rows, err = s.db.QueryContext(ctx,
`SELECT m.id, m.from_nick, m.body, m.target, m.created_at
FROM messages m
WHERE m.created_at < ?
AND ((m.from_user_id = ? AND m.target = ?) OR (m.from_user_id = ? AND m.target = ?))
ORDER BY m.created_at DESC LIMIT ?`,
beforeTS, userA, userB, userB, userA, limit)
} else {
rows, err = s.db.QueryContext(ctx,
`SELECT m.id, m.from_nick, m.body, m.target, m.created_at
FROM messages m
WHERE (m.from_user_id = ? AND m.target = ?) OR (m.from_user_id = ? AND m.target = ?)
ORDER BY m.created_at DESC LIMIT ?`,
userA, userB, userB, userA, limit)
}
rows, err := s.db.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
msgs, err := scanDMMessages(rows)
if err != nil {
return nil, err
defer func() { _ = rows.Close() }()
msgs := []MessageInfo{}
for rows.Next() {
var m MessageInfo
if err := rows.Scan(&m.ID, &m.Nick, &m.Content, &m.DMTarget, &m.CreatedAt); err != nil {
return nil, err
}
m.IsDM = true
msgs = append(msgs, m)
}
reverseMessages(msgs)
// Reverse to ascending order.
for i, j := 0, len(msgs)-1; i < j; i, j = i+1, j-1 {
msgs[i], msgs[j] = msgs[j], msgs[i]
}
return msgs, nil
return msgs, rows.Err()
}
// ChangeNick updates a user's nickname.
func (s *Database) ChangeNick(ctx context.Context, userID int64, newNick string) error {
func (s *Database) ChangeNick(ctx context.Context, userID string, newNick string) error {
_, err := s.db.ExecContext(ctx,
"UPDATE users SET nick = ? WHERE id = ?", newNick, userID)
@@ -341,7 +315,7 @@ func (s *Database) ChangeNick(ctx context.Context, userID int64, newNick string)
}
// SetTopic sets the topic for a channel.
func (s *Database) SetTopic(ctx context.Context, channelName string, _ int64, topic string) error {
func (s *Database) SetTopic(ctx context.Context, channelName string, _ string, topic string) error {
_, err := s.db.ExecContext(ctx,
"UPDATE channels SET topic = ? WHERE name = ?", topic, channelName)
@@ -361,173 +335,18 @@ func (s *Database) ListAllChannels(ctx context.Context) ([]ChannelInfo, error) {
return nil, err
}
return scanChannelInfoRows(rows)
}
// --- Helper functions ---
func scanChannelInfoRows(rows *sql.Rows) ([]ChannelInfo, error) {
defer func() { _ = rows.Close() }()
var channels []ChannelInfo
channels := []ChannelInfo{}
for rows.Next() {
var ch ChannelInfo
scanErr := rows.Scan(&ch.ID, &ch.Name, &ch.Topic)
if scanErr != nil {
return nil, scanErr
if err := rows.Scan(&ch.ID, &ch.Name, &ch.Topic); err != nil {
return nil, err
}
channels = append(channels, ch)
}
err := rows.Err()
if err != nil {
return nil, err
}
if channels == nil {
channels = []ChannelInfo{}
}
return channels, nil
}
func scanChannelMessages(rows *sql.Rows) ([]MessageInfo, error) {
defer func() { _ = rows.Close() }()
var msgs []MessageInfo
for rows.Next() {
var m MessageInfo
scanErr := rows.Scan(&m.ID, &m.Channel, &m.Nick, &m.Content, &m.CreatedAt)
if scanErr != nil {
return nil, scanErr
}
msgs = append(msgs, m)
}
err := rows.Err()
if err != nil {
return nil, err
}
if msgs == nil {
msgs = []MessageInfo{}
}
return msgs, nil
}
func scanDMMessages(rows *sql.Rows) ([]MessageInfo, error) {
defer func() { _ = rows.Close() }()
var msgs []MessageInfo
for rows.Next() {
var m MessageInfo
scanErr := rows.Scan(&m.ID, &m.Nick, &m.Content, &m.DMTarget, &m.CreatedAt)
if scanErr != nil {
return nil, scanErr
}
m.IsDM = true
msgs = append(msgs, m)
}
err := rows.Err()
if err != nil {
return nil, err
}
if msgs == nil {
msgs = []MessageInfo{}
}
return msgs, nil
}
func scanPollMessages(rows *sql.Rows) ([]MessageInfo, error) {
defer func() { _ = rows.Close() }()
var msgs []MessageInfo
for rows.Next() {
var m MessageInfo
var isDM int
scanErr := rows.Scan(
&m.ID, &m.Channel, &m.Nick, &m.Content, &isDM, &m.DMTarget, &m.CreatedAt,
)
if scanErr != nil {
return nil, scanErr
}
m.IsDM = isDM == 1
msgs = append(msgs, m)
}
err := rows.Err()
if err != nil {
return nil, err
}
if msgs == nil {
msgs = []MessageInfo{}
}
return msgs, nil
}
func buildChannelHistoryQuery(channelID, beforeID int64, limit int) (string, []any) {
if beforeID > 0 {
return `SELECT m.id, c.name, u.nick, m.content, m.created_at
FROM messages m
INNER JOIN users u ON u.id = m.user_id
INNER JOIN channels c ON c.id = m.channel_id
WHERE m.channel_id = ? AND m.is_dm = 0 AND m.id < ?
ORDER BY m.id DESC LIMIT ?`, []any{channelID, beforeID, limit}
}
return `SELECT m.id, c.name, u.nick, m.content, m.created_at
FROM messages m
INNER JOIN users u ON u.id = m.user_id
INNER JOIN channels c ON c.id = m.channel_id
WHERE m.channel_id = ? AND m.is_dm = 0
ORDER BY m.id DESC LIMIT ?`, []any{channelID, limit}
}
func buildDMHistoryQuery(userA, userB, beforeID int64, limit int) (string, []any) {
if beforeID > 0 {
return `SELECT m.id, u.nick, m.content, t.nick, m.created_at
FROM messages m
INNER JOIN users u ON u.id = m.user_id
INNER JOIN users t ON t.id = m.dm_target_id
WHERE m.is_dm = 1 AND m.id < ?
AND ((m.user_id = ? AND m.dm_target_id = ?)
OR (m.user_id = ? AND m.dm_target_id = ?))
ORDER BY m.id DESC LIMIT ?`,
[]any{beforeID, userA, userB, userB, userA, limit}
}
return `SELECT m.id, u.nick, m.content, t.nick, m.created_at
FROM messages m
INNER JOIN users u ON u.id = m.user_id
INNER JOIN users t ON t.id = m.dm_target_id
WHERE m.is_dm = 1
AND ((m.user_id = ? AND m.dm_target_id = ?)
OR (m.user_id = ? AND m.dm_target_id = ?))
ORDER BY m.id DESC LIMIT ?`,
[]any{userA, userB, userB, userA, limit}
}
func reverseMessages(msgs []MessageInfo) {
for i, j := 0, len(msgs)-1; i < j; i, j = i+1, j-1 {
msgs[i], msgs[j] = msgs[j], msgs[i]
}
return channels, rows.Err()
}

43
internal/db/schema/003_users.sql
View File

@@ -1,16 +1,31 @@
-- Migration 003: Add simple user auth columns.
-- This migration adds token-based auth support for the web client.
-- Tables created by 002 (with TEXT ids) take precedence via IF NOT EXISTS.
-- We only add columns/indexes that don't already exist.
PRAGMA foreign_keys = ON;
-- Add token column to users table if it doesn't exist.
-- SQLite doesn't support IF NOT EXISTS for ALTER TABLE ADD COLUMN,
-- so we check via pragma first.
CREATE TABLE IF NOT EXISTS _migration_003_check (done INTEGER);
INSERT OR IGNORE INTO _migration_003_check VALUES (1);
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nick TEXT NOT NULL UNIQUE,
token TEXT NOT NULL UNIQUE,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
);
-- The web chat client's simple tables are only created if migration 002
-- didn't already create them with the ORM schema.
-- Since 002 creates all needed tables, 003 is effectively a no-op
-- when run after 002.
DROP TABLE IF EXISTS _migration_003_check;
CREATE TABLE IF NOT EXISTS channel_members (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id INTEGER NOT NULL REFERENCES channels(id) ON DELETE CASCADE,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
joined_at DATETIME DEFAULT CURRENT_TIMESTAMP,
UNIQUE(channel_id, user_id)
);
CREATE TABLE IF NOT EXISTS messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
channel_id INTEGER REFERENCES channels(id) ON DELETE CASCADE,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
content TEXT NOT NULL,
is_dm INTEGER NOT NULL DEFAULT 0,
dm_target_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel_id, created_at);
CREATE INDEX IF NOT EXISTS idx_messages_dm ON messages(user_id, dm_target_id, created_at);
CREATE INDEX IF NOT EXISTS idx_users_token ON users(token);

420
internal/handlers/api.go
View File

@@ -1,7 +1,9 @@
package handlers
import (
"crypto/rand"
"database/sql"
"encoding/hex"
"encoding/json"
"net/http"
"strconv"
@@ -11,66 +13,70 @@ import (
"github.com/go-chi/chi"
)
const maxNickLen = 32
// authUser extracts the user from the Authorization header (Bearer token).
func (s *Handlers) authUser(r *http.Request) (int64, string, error) {
func (s *Handlers) authUser(r *http.Request) (string, string, error) {
auth := r.Header.Get("Authorization")
if !strings.HasPrefix(auth, "Bearer ") {
return 0, "", sql.ErrNoRows
return "", "", sql.ErrNoRows
}
token := strings.TrimPrefix(auth, "Bearer ")
return s.params.Database.LookupUserByToken(r.Context(), token)
u, err := s.params.Database.GetUserByToken(r.Context(), token)
if err != nil {
return "", "", err
}
return u.ID, u.Nick, nil
}
func (s *Handlers) requireAuth(w http.ResponseWriter, r *http.Request) (int64, string, bool) {
func (s *Handlers) requireAuth(w http.ResponseWriter, r *http.Request) (string, string, bool) {
uid, nick, err := s.authUser(r)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "unauthorized"}, http.StatusUnauthorized)
return 0, "", false
return "", "", false
}
return uid, nick, true
}
func generateID() string {
b := make([]byte, 16)
_, _ = rand.Read(b)
return hex.EncodeToString(b)
}
// HandleCreateSession creates a new user session and returns the auth token.
func (s *Handlers) HandleCreateSession() http.HandlerFunc {
type request struct {
Nick string `json:"nick"`
}
type response struct {
ID int64 `json:"id"`
ID string `json:"id"`
Nick string `json:"nick"`
Token string `json:"token"`
}
return func(w http.ResponseWriter, r *http.Request) {
var req request
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
s.respondJSON(w, r, map[string]string{"error": "invalid request"}, http.StatusBadRequest)
return
}
req.Nick = strings.TrimSpace(req.Nick)
if req.Nick == "" || len(req.Nick) > maxNickLen {
if req.Nick == "" || len(req.Nick) > 32 {
s.respondJSON(w, r, map[string]string{"error": "nick must be 1-32 characters"}, http.StatusBadRequest)
return
}
id, token, err := s.params.Database.CreateSimpleUser(r.Context(), req.Nick)
id := generateID()
u, err := s.params.Database.CreateUser(r.Context(), id, req.Nick, "")
if err != nil {
if strings.Contains(err.Error(), "UNIQUE") {
s.respondJSON(w, r, map[string]string{"error": "nick already taken"}, http.StatusConflict)
return
}
@@ -80,14 +86,24 @@ func (s *Handlers) HandleCreateSession() http.HandlerFunc {
return
}
s.respondJSON(w, r, &response{ID: id, Nick: req.Nick, Token: token}, http.StatusCreated)
tokenStr := generateID()
_, err = s.params.Database.CreateAuthToken(r.Context(), tokenStr, u.ID)
if err != nil {
s.log.Error("create auth token failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, &response{ID: u.ID, Nick: req.Nick, Token: tokenStr}, http.StatusCreated)
}
}
// HandleState returns the current user's info and joined channels.
func (s *Handlers) HandleState() http.HandlerFunc {
type response struct {
ID int64 `json:"id"`
ID string `json:"id"`
Nick string `json:"nick"`
Channels []db.ChannelInfo `json:"channels"`
}
@@ -140,10 +156,12 @@ func (s *Handlers) HandleChannelMembers() http.HandlerFunc {
name := "#" + chi.URLParam(r, "channel")
chID, err := s.lookupChannelID(r, name)
var chID string
err := s.params.Database.GetDB().QueryRowContext(r.Context(),
"SELECT id FROM channels WHERE name = ?", name).Scan(&chID)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
return
}
@@ -168,10 +186,10 @@ func (s *Handlers) HandleGetMessages() http.HandlerFunc {
return
}
afterID, _ := strconv.ParseInt(r.URL.Query().Get("after"), 10, 64)
afterTS := r.URL.Query().Get("after")
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
msgs, err := s.params.Database.PollMessages(r.Context(), uid, afterID, limit)
msgs, err := s.params.Database.PollMessages(r.Context(), uid, afterTS, limit)
if err != nil {
s.log.Error("get messages failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
@@ -186,157 +204,134 @@ func (s *Handlers) HandleGetMessages() http.HandlerFunc {
// HandleSendCommand handles all C2S commands via POST /messages.
// The "command" field dispatches to the appropriate logic.
func (s *Handlers) HandleSendCommand() http.HandlerFunc {
type request struct {
Command string `json:"command"`
To string `json:"to"`
Params []string `json:"params,omitempty"`
Body interface{} `json:"body,omitempty"`
}
return func(w http.ResponseWriter, r *http.Request) {
uid, nick, ok := s.requireAuth(w, r)
if !ok {
return
}
cmd, err := s.decodeSendCommand(r)
if err != nil {
var req request
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
s.respondJSON(w, r, map[string]string{"error": "invalid request"}, http.StatusBadRequest)
return
}
switch cmd.Command {
case "PRIVMSG", "NOTICE":
s.handlePrivmsgCommand(w, r, uid, cmd)
case "JOIN":
s.handleJoinCommand(w, r, uid, cmd)
case "PART":
s.handlePartCommand(w, r, uid, cmd)
case "NICK":
s.handleNickCommand(w, r, uid, cmd)
case "TOPIC":
s.handleTopicCommand(w, r, cmd)
case "PING":
s.respondJSON(w, r, map[string]string{"command": "PONG", "from": s.params.Config.ServerName}, http.StatusOK)
default:
_ = nick // suppress unused warning
req.Command = strings.ToUpper(strings.TrimSpace(req.Command))
req.To = strings.TrimSpace(req.To)
s.respondJSON(w, r, map[string]string{"error": "unknown command: " + cmd.Command}, http.StatusBadRequest)
}
}
}
// Helper to extract body as string lines.
bodyLines := func() []string {
switch v := req.Body.(type) {
case []interface{}:
lines := make([]string, 0, len(v))
type sendCommand struct {
Command string `json:"command"`
To string `json:"to"`
Params []string `json:"params,omitempty"`
Body any `json:"body,omitempty"`
}
for _, item := range v {
if str, ok := item.(string); ok {
lines = append(lines, str)
}
}
func (s *Handlers) decodeSendCommand(r *http.Request) (*sendCommand, error) {
var cmd sendCommand
err := json.NewDecoder(r.Body).Decode(&cmd)
if err != nil {
return nil, err
}
cmd.Command = strings.ToUpper(strings.TrimSpace(cmd.Command))
cmd.To = strings.TrimSpace(cmd.To)
return &cmd, nil
}
func bodyLines(body any) []string {
switch v := body.(type) {
case []any:
lines := make([]string, 0, len(v))
for _, item := range v {
if str, ok := item.(string); ok {
lines = append(lines, str)
return lines
case []string:
return v
default:
return nil
}
}
return lines
case []string:
return v
default:
return nil
switch req.Command {
case "PRIVMSG", "NOTICE":
s.handlePrivmsg(w, r, uid, nick, req.To, bodyLines())
case "JOIN":
s.handleJoin(w, r, uid, req.To)
case "PART":
s.handlePart(w, r, uid, req.To)
case "NICK":
s.handleNick(w, r, uid, bodyLines())
case "TOPIC":
s.handleTopic(w, r, uid, req.To, bodyLines())
case "PING":
s.respondJSON(w, r, map[string]string{"command": "PONG", "from": s.params.Config.ServerName}, http.StatusOK)
default:
_ = nick // suppress unused warning
s.respondJSON(w, r, map[string]string{"error": "unknown command: " + req.Command}, http.StatusBadRequest)
}
}
}
func (s *Handlers) handlePrivmsgCommand(
w http.ResponseWriter, r *http.Request, uid int64, cmd *sendCommand,
) {
if cmd.To == "" {
func (s *Handlers) handlePrivmsg(w http.ResponseWriter, r *http.Request, uid, nick, to string, lines []string) {
if to == "" {
s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
return
}
lines := bodyLines(cmd.Body)
if len(lines) == 0 {
s.respondJSON(w, r, map[string]string{"error": "body required"}, http.StatusBadRequest)
return
}
content := strings.Join(lines, "\n")
if strings.HasPrefix(cmd.To, "#") {
s.sendChannelMessage(w, r, uid, cmd.To, content)
if strings.HasPrefix(to, "#") {
// Channel message.
var chID string
err := s.params.Database.GetDB().QueryRowContext(r.Context(),
"SELECT id FROM channels WHERE name = ?", to).Scan(&chID)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
return
}
msgID, err := s.params.Database.SendMessage(r.Context(), chID, uid, nick, content)
if err != nil {
s.log.Error("send message failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
} else {
s.sendDirectMessage(w, r, uid, cmd.To, content)
// DM.
targetUser, err := s.params.Database.GetUserByNick(r.Context(), to)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
return
}
msgID, err := s.params.Database.SendDM(r.Context(), uid, nick, targetUser.ID, content)
if err != nil {
s.log.Error("send dm failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
}
}
func (s *Handlers) sendChannelMessage(
w http.ResponseWriter, r *http.Request, uid int64, channel, content string,
) {
chID, err := s.lookupChannelID(r, channel)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
return
}
msgID, err := s.params.Database.SendMessage(r.Context(), chID, uid, content)
if err != nil {
s.log.Error("send message failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
}
func (s *Handlers) sendDirectMessage(
w http.ResponseWriter, r *http.Request, uid int64, toNick, content string,
) {
targetID, err := s.params.Database.LookupUserByNick(r.Context(), toNick)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
return
}
msgID, err := s.params.Database.SendDM(r.Context(), uid, targetID, content)
if err != nil {
s.log.Error("send dm failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
}
func (s *Handlers) handleJoinCommand(
w http.ResponseWriter, r *http.Request, uid int64, cmd *sendCommand,
) {
if cmd.To == "" {
func (s *Handlers) handleJoin(w http.ResponseWriter, r *http.Request, uid, to string) {
if to == "" {
s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
return
}
channel := cmd.To
channel := to
if !strings.HasPrefix(channel, "#") {
channel = "#" + channel
}
@@ -349,8 +344,7 @@ func (s *Handlers) handleJoinCommand(
return
}
err = s.params.Database.JoinChannel(r.Context(), chID, uid)
if err != nil {
if err := s.params.Database.JoinChannel(r.Context(), chID, uid); err != nil {
s.log.Error("join channel failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
@@ -360,29 +354,27 @@ func (s *Handlers) handleJoinCommand(
s.respondJSON(w, r, map[string]string{"status": "joined", "channel": channel}, http.StatusOK)
}
func (s *Handlers) handlePartCommand(
w http.ResponseWriter, r *http.Request, uid int64, cmd *sendCommand,
) {
if cmd.To == "" {
func (s *Handlers) handlePart(w http.ResponseWriter, r *http.Request, uid, to string) {
if to == "" {
s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
return
}
channel := cmd.To
channel := to
if !strings.HasPrefix(channel, "#") {
channel = "#" + channel
}
chID, err := s.lookupChannelID(r, channel)
var chID string
err := s.params.Database.GetDB().QueryRowContext(r.Context(),
"SELECT id FROM channels WHERE name = ?", channel).Scan(&chID)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
return
}
err = s.params.Database.PartChannel(r.Context(), chID, uid)
if err != nil {
if err := s.params.Database.PartChannel(r.Context(), chID, uid); err != nil {
s.log.Error("part channel failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
@@ -392,28 +384,21 @@ func (s *Handlers) handlePartCommand(
s.respondJSON(w, r, map[string]string{"status": "parted", "channel": channel}, http.StatusOK)
}
func (s *Handlers) handleNickCommand(
w http.ResponseWriter, r *http.Request, uid int64, cmd *sendCommand,
) {
lines := bodyLines(cmd.Body)
func (s *Handlers) handleNick(w http.ResponseWriter, r *http.Request, uid string, lines []string) {
if len(lines) == 0 {
s.respondJSON(w, r, map[string]string{"error": "body required (new nick)"}, http.StatusBadRequest)
return
}
newNick := strings.TrimSpace(lines[0])
if newNick == "" || len(newNick) > maxNickLen {
if newNick == "" || len(newNick) > 32 {
s.respondJSON(w, r, map[string]string{"error": "nick must be 1-32 characters"}, http.StatusBadRequest)
return
}
err := s.params.Database.ChangeNick(r.Context(), uid, newNick)
if err != nil {
if err := s.params.Database.ChangeNick(r.Context(), uid, newNick); err != nil {
if strings.Contains(err.Error(), "UNIQUE") {
s.respondJSON(w, r, map[string]string{"error": "nick already in use"}, http.StatusConflict)
return
}
@@ -426,31 +411,25 @@ func (s *Handlers) handleNickCommand(
s.respondJSON(w, r, map[string]string{"status": "ok", "nick": newNick}, http.StatusOK)
}
func (s *Handlers) handleTopicCommand(
w http.ResponseWriter, r *http.Request, cmd *sendCommand,
) {
if cmd.To == "" {
func (s *Handlers) handleTopic(w http.ResponseWriter, r *http.Request, uid, to string, lines []string) {
if to == "" {
s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
return
}
lines := bodyLines(cmd.Body)
if len(lines) == 0 {
s.respondJSON(w, r, map[string]string{"error": "body required (topic text)"}, http.StatusBadRequest)
return
}
topic := strings.Join(lines, " ")
channel := cmd.To
channel := to
if !strings.HasPrefix(channel, "#") {
channel = "#" + channel
}
err := s.params.Database.SetTopic(r.Context(), channel, 0, topic)
if err != nil {
if err := s.params.Database.SetTopic(r.Context(), channel, uid, topic); err != nil {
s.log.Error("set topic failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
@@ -471,82 +450,57 @@ func (s *Handlers) HandleGetHistory() http.HandlerFunc {
target := r.URL.Query().Get("target")
if target == "" {
s.respondJSON(w, r, map[string]string{"error": "target required"}, http.StatusBadRequest)
return
}
beforeID, _ := strconv.ParseInt(r.URL.Query().Get("before"), 10, 64)
beforeTS := r.URL.Query().Get("before")
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
if limit <= 0 {
limit = defaultHistoryLimit
limit = 50
}
if strings.HasPrefix(target, "#") {
s.handleChannelHistory(w, r, target, beforeID, limit)
// Channel history — look up channel by name to get its ID for target matching.
var chID string
err := s.params.Database.GetDB().QueryRowContext(r.Context(),
"SELECT id FROM channels WHERE name = ?", target).Scan(&chID)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
return
}
msgs, err := s.params.Database.GetMessagesBefore(r.Context(), chID, beforeTS, limit)
if err != nil {
s.log.Error("get history failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, msgs, http.StatusOK)
} else {
s.handleDMHistory(w, r, uid, target, beforeID, limit)
// DM history.
targetUser, err := s.params.Database.GetUserByNick(r.Context(), target)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
return
}
msgs, err := s.params.Database.GetDMsBefore(r.Context(), uid, targetUser.ID, beforeTS, limit)
if err != nil {
s.log.Error("get dm history failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, msgs, http.StatusOK)
}
}
}
const defaultHistoryLimit = 50
func (s *Handlers) handleChannelHistory(
w http.ResponseWriter, r *http.Request,
target string, beforeID int64, limit int,
) {
chID, err := s.lookupChannelID(r, target)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
return
}
msgs, err := s.params.Database.GetMessagesBefore(r.Context(), chID, beforeID, limit)
if err != nil {
s.log.Error("get history failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, msgs, http.StatusOK)
}
func (s *Handlers) handleDMHistory(
w http.ResponseWriter, r *http.Request,
uid int64, target string, beforeID int64, limit int,
) {
targetID, err := s.params.Database.LookupUserByNick(r.Context(), target)
if err != nil {
s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
return
}
msgs, err := s.params.Database.GetDMsBefore(r.Context(), uid, targetID, beforeID, limit)
if err != nil {
s.log.Error("get dm history failed", "error", err)
s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
return
}
s.respondJSON(w, r, msgs, http.StatusOK)
}
// lookupChannelID queries the channel ID by name using a parameterized query.
func (s *Handlers) lookupChannelID(r *http.Request, name string) (int64, error) {
var chID int64
//nolint:gosec // query uses parameterized placeholder (?), not string interpolation
err := s.params.Database.GetDB().QueryRowContext(r.Context(),
"SELECT id FROM channels WHERE name = ?", name).Scan(&chID)
return chID, err
}
// HandleServerInfo returns server metadata (MOTD, name).
func (s *Handlers) HandleServerInfo() http.HandlerFunc {
type response struct {

11
internal/models/auth_token.go
View File

@@ -2,13 +2,10 @@ package models
import (
"context"
"errors"
"fmt"
"time"
)
// ErrUserLookupNotAvailable is returned when user lookup is not configured.
var ErrUserLookupNotAvailable = errors.New("user lookup not available")
// AuthToken represents an authentication token for a user session.
type AuthToken struct {
Base
@@ -22,5 +19,9 @@ type AuthToken struct {
// User returns the user who owns this token.
func (t *AuthToken) User(ctx context.Context) (*User, error) {
return t.LookupUser(ctx, t.UserID)
if ul := t.GetUserLookup(); ul != nil {
return ul.GetUserByID(ctx, t.UserID)
}
return nil, fmt.Errorf("user lookup not available")
}

17
internal/models/channel_member.go
View File

@@ -2,13 +2,10 @@ package models
import (
"context"
"errors"
"fmt"
"time"
)
// ErrChannelLookupNotAvailable is returned when channel lookup is not configured.
var ErrChannelLookupNotAvailable = errors.New("channel lookup not available")
// ChannelMember represents a user's membership in a channel.
type ChannelMember struct {
Base
@@ -22,10 +19,18 @@ type ChannelMember struct {
// User returns the full User for this membership.
func (cm *ChannelMember) User(ctx context.Context) (*User, error) {
return cm.LookupUser(ctx, cm.UserID)
if ul := cm.GetUserLookup(); ul != nil {
return ul.GetUserByID(ctx, cm.UserID)
}
return nil, fmt.Errorf("user lookup not available")
}
// Channel returns the full Channel for this membership.
func (cm *ChannelMember) Channel(ctx context.Context) (*Channel, error) {
return cm.LookupChannel(ctx, cm.ChannelID)
if cl := cm.GetChannelLookup(); cl != nil {
return cl.GetChannelByID(ctx, cm.ChannelID)
}
return nil, fmt.Errorf("channel lookup not available")
}

22
internal/models/model.go
View File

@@ -39,22 +39,20 @@ func (b *Base) GetDB() *sql.DB {
return b.db.GetDB()
}
// LookupUser looks up a user by ID if the database supports it.
func (b *Base) LookupUser(ctx context.Context, id string) (*User, error) {
ul, ok := b.db.(UserLookup)
if !ok {
return nil, ErrUserLookupNotAvailable
// GetUserLookup returns the DB as a UserLookup if it implements the interface.
func (b *Base) GetUserLookup() UserLookup {
if ul, ok := b.db.(UserLookup); ok {
return ul
}
return ul.GetUserByID(ctx, id)
return nil
}
// LookupChannel looks up a channel by ID if the database supports it.
func (b *Base) LookupChannel(ctx context.Context, id string) (*Channel, error) {
cl, ok := b.db.(ChannelLookup)
if !ok {
return nil, ErrChannelLookupNotAvailable
// GetChannelLookup returns the DB as a ChannelLookup if it implements the interface.
func (b *Base) GetChannelLookup() ChannelLookup {
if cl, ok := b.db.(ChannelLookup); ok {
return cl
}
return cl.GetChannelByID(ctx, id)
return nil
}

7
internal/models/session.go
View File

@@ -2,6 +2,7 @@ package models
import (
"context"
"fmt"
"time"
)
@@ -18,5 +19,9 @@ type Session struct {
// User returns the user who owns this session.
func (s *Session) User(ctx context.Context) (*User, error) {
return s.LookupUser(ctx, s.UserID)
if ul := s.GetUserLookup(); ul != nil {
return ul.GetUserByID(ctx, s.UserID)
}
return nil, fmt.Errorf("user lookup not available")
}

59
internal/server/routes.go
View File

@@ -20,13 +20,6 @@ const routeTimeout = 60 * time.Second
func (s *Server) SetupRoutes() {
s.router = chi.NewRouter()
s.setupMiddleware()
s.setupHealthAndMetrics()
s.setupAPIRoutes()
s.setupSPA()
}
func (s *Server) setupMiddleware() {
s.router.Use(middleware.Recoverer)
s.router.Use(middleware.RequestID)
s.router.Use(s.mw.Logging())
@@ -44,63 +37,51 @@ func (s *Server) setupMiddleware() {
})
s.router.Use(sentryHandler.Handle)
}
}
func (s *Server) setupHealthAndMetrics() {
// Health check
s.router.Get("/.well-known/healthcheck.json", s.h.HandleHealthCheck())
// Protected metrics endpoint
if viper.GetString("METRICS_USERNAME") != "" {
s.router.Group(func(r chi.Router) {
r.Use(s.mw.MetricsAuth())
r.Get("/metrics", http.HandlerFunc(promhttp.Handler().ServeHTTP))
})
}
}
func (s *Server) setupAPIRoutes() {
// API v1
s.router.Route("/api/v1", func(r chi.Router) {
r.Get("/server", s.h.HandleServerInfo())
r.Post("/session", s.h.HandleCreateSession())
// Unified state and message endpoints
r.Get("/state", s.h.HandleState())
r.Get("/messages", s.h.HandleGetMessages())
r.Post("/messages", s.h.HandleSendCommand())
r.Get("/history", s.h.HandleGetHistory())
// Channels
r.Get("/channels", s.h.HandleListAllChannels())
r.Get("/channels/{channel}/members", s.h.HandleChannelMembers())
})
}
func (s *Server) setupSPA() {
// Serve embedded SPA
distFS, err := fs.Sub(web.Dist, "dist")
if err != nil {
s.log.Error("failed to get web dist filesystem", "error", err)
return
} else {
fileServer := http.FileServer(http.FS(distFS))
s.router.Get("/*", func(w http.ResponseWriter, r *http.Request) {
// Try to serve the file; if not found, serve index.html for SPA routing
f, err := distFS.(fs.ReadFileFS).ReadFile(r.URL.Path[1:])
if err != nil || len(f) == 0 {
indexHTML, _ := distFS.(fs.ReadFileFS).ReadFile("index.html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(indexHTML)
return
}
fileServer.ServeHTTP(w, r)
})
}
fileServer := http.FileServer(http.FS(distFS))
s.router.Get("/*", func(w http.ResponseWriter, r *http.Request) {
readFS, ok := distFS.(fs.ReadFileFS)
if !ok {
http.NotFound(w, r)
return
}
f, readErr := readFS.ReadFile(r.URL.Path[1:])
if readErr != nil || len(f) == 0 {
indexHTML, _ := readFS.ReadFile("index.html")
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(indexHTML)
return
}
fileServer.ServeHTTP(w, r)
})
}