mirror of
https://github.com/logos-messaging/nim-chat-poc.git
synced 2026-01-05 15:43:13 +00:00
581 lines
15 KiB
Nim
581 lines
15 KiB
Nim
|
|
import algorithm
|
|
import chronicles
|
|
import chronos
|
|
import illwill
|
|
import libp2p/crypto/crypto
|
|
import times
|
|
import strformat
|
|
import strutils
|
|
import sugar
|
|
import tables
|
|
|
|
import chat_sdk
|
|
import content_types/all
|
|
|
|
import layout
|
|
import persistence
|
|
import utils
|
|
|
|
const charVert = "│"
|
|
const charHoriz = "─"
|
|
const charTopLeft = "┌"
|
|
const charTopRight = "┐"
|
|
const charBottomLeft = "└"
|
|
const charBottomRight = "┘"
|
|
|
|
type
|
|
|
|
LogEntry = object
|
|
level: string
|
|
ts: DateTime
|
|
msg: string
|
|
|
|
Message = object
|
|
sender: string
|
|
content: string
|
|
timestamp: DateTime
|
|
id: string
|
|
isAcknowledged: bool
|
|
|
|
ConvoInfo = object
|
|
name: string
|
|
convo: Conversation
|
|
messages: seq[Message]
|
|
lastMsgTime*: DateTime
|
|
isTooLong*: bool
|
|
|
|
ChatApp = ref object
|
|
client: Client
|
|
tb: TerminalBuffer
|
|
conversations: Table[string, ConvoInfo]
|
|
selectedConv: string
|
|
inputBuffer: string
|
|
inputInviteBuffer: string
|
|
scrollOffset: int
|
|
messageScrollOffset: int
|
|
inviteModal: bool
|
|
|
|
currentInviteLink: string
|
|
isInviteReady: bool
|
|
peerCount: int
|
|
|
|
logMsgs: seq[LogEntry]
|
|
|
|
proc `==`(a,b: ConvoInfo):bool =
|
|
if a.name==b.name:
|
|
true
|
|
else:
|
|
false
|
|
|
|
|
|
#################################################
|
|
# Data Management
|
|
#################################################
|
|
|
|
proc addMessage(conv: var ConvoInfo, messageId: MessageId, sender: string, content: string) =
|
|
|
|
let now = now()
|
|
conv.messages.add(Message(
|
|
sender: sender,
|
|
id: messageId,
|
|
content: content,
|
|
timestamp: now,
|
|
isAcknowledged: false
|
|
))
|
|
conv.lastMsgTime = now
|
|
|
|
|
|
proc mostRecentConvos(app: ChatApp): seq[ConvoInfo] =
|
|
var convos = collect(for v in app.conversations.values: v)
|
|
convos.sort(proc(a, b: ConvoInfo): int = -cmp(a.lastMsgTime, b.lastMsgTime))
|
|
|
|
return convos
|
|
|
|
proc getSelectedConvo(app: ChatApp): ptr ConvoInfo =
|
|
if app.conversations.hasKey(app.selectedConv):
|
|
return addr app.conversations[app.selectedConv]
|
|
|
|
return addr app.conversations[app.mostRecentConvos()[0].name]
|
|
|
|
|
|
|
|
#################################################
|
|
# ChatSDK Setup
|
|
#################################################
|
|
|
|
proc createChatClient(name: string): Future[Client] {.async.} =
|
|
var cfg = await getCfg(name)
|
|
for key, val in fetchRegistrations():
|
|
if key != name:
|
|
cfg.waku.staticPeers.add(val)
|
|
|
|
result = newClient(cfg.waku, cfg.ident)
|
|
|
|
|
|
proc createInviteLink(app: var ChatApp): string =
|
|
app.client.createIntroBundle().toLink()
|
|
|
|
|
|
proc createConvo(app: ChatApp) {.async.} =
|
|
discard await app.client.newPrivateConversation(toBundle(app.inputInviteBuffer.strip()).get())
|
|
|
|
proc sendMessage(app: ChatApp, convoInfo: ptr ConvoInfo, msg: string) {.async.} =
|
|
|
|
var msgId = ""
|
|
if convoInfo.convo != nil:
|
|
msgId = await convoInfo.convo.sendMessage(app.client.ds, initTextFrame(msg).toContentFrame())
|
|
|
|
convoInfo[].addMessage(msgId, "You", app.inputBuffer)
|
|
|
|
|
|
proc setupChatSdk(app: ChatApp) =
|
|
|
|
let client = app.client
|
|
|
|
app.client.onNewMessage(proc(convo: Conversation, msg: ContentFrame) {.async.} =
|
|
info "New Message: ", convoId = convo.id(), msg= msg
|
|
app.logMsgs.add(LogEntry(level: "info",ts: now(), msg: "NewMsg"))
|
|
|
|
var contentStr = case msg.contentType
|
|
of text:
|
|
decode(msg.bytes, TextFrame).get().text
|
|
of unknown:
|
|
"<Unhandled Message Type>"
|
|
|
|
app.conversations[convo.id()].messages.add(Message(sender: "???", content: contentStr, timestamp: now()))
|
|
)
|
|
|
|
app.client.onNewConversation(proc(convo: Conversation) {.async.} =
|
|
app.logMsgs.add(LogEntry(level: "info",ts: now(), msg: fmt"Adding Convo: {convo.id()}"))
|
|
info "New Conversation: ", convoId = convo.id()
|
|
|
|
app.conversations[convo.id()] = ConvoInfo(name: convo.id(), convo: convo, messages: @[], lastMsgTime: now(), isTooLong: false)
|
|
)
|
|
|
|
app.client.onDeliveryAck(proc(convo: Conversation, msgId: string) {.async.} =
|
|
info "DeliveryAck", msgId=msgId
|
|
app.logMsgs.add(LogEntry(level: "info",ts: now(), msg: fmt"Ack:{msgId}"))
|
|
|
|
var s = ""
|
|
var msgs = addr app.conversations[convo.id()].messages
|
|
for i in countdown(msgs[].high, 0):
|
|
s = fmt"{s},{msgs[i].id}"
|
|
var m = addr msgs[i]
|
|
|
|
if m.id == msgId:
|
|
m.isAcknowledged = true
|
|
break # Stop after
|
|
)
|
|
|
|
|
|
#################################################
|
|
# Draw Funcs
|
|
#################################################
|
|
|
|
proc resetTuiCursor(tb: var TerminalBuffer) =
|
|
tb.setForegroundColor(fgWhite)
|
|
tb.setBackgroundColor(bgBlack)
|
|
|
|
|
|
proc drawOutline(tb: var TerminalBuffer, layout: Pane, color: ForegroundColor,
|
|
bg: BackgroundColor = bgBlack) =
|
|
|
|
for x in layout.xStart+1..<layout.xStart+layout.width:
|
|
tb.write(x, layout.yStart, charHoriz, color, bg)
|
|
tb.write(x, layout.yStart+layout.height-1, charHoriz, color, bg)
|
|
|
|
for y in layout.yStart+1..<layout.yStart+layout.height:
|
|
tb.write(layout.xStart, y, charVert, color, bg)
|
|
tb.write(layout.xStart+layout.width-1, y, charVert, color, bg)
|
|
|
|
tb.write(layout.xStart, layout.yStart, charTopLeft, color, bg)
|
|
tb.write(layout.xStart+layout.width-1, layout.yStart, charTopRight, color, bg)
|
|
tb.write(layout.xStart, layout.yStart+layout.height-1, charBottomLeft, color, bg)
|
|
tb.write(layout.xStart+layout.width-1, layout.yStart+layout.height-1,
|
|
charBottomRight, color, bgBlack)
|
|
|
|
|
|
proc drawStatusBar(app: ChatApp, layout: Pane , fg: ForegroundColor, bg: BackgroundColor) =
|
|
var tb = app.tb
|
|
tb.setForegroundColor(fg)
|
|
tb.setBackgroundColor(bg)
|
|
|
|
for x in layout.xStart..<layout.width:
|
|
for y in layout.yStart..<layout.height:
|
|
tb.write(x, y, " ")
|
|
|
|
var i = layout.yStart + 1
|
|
var chunk = layout.width - 9
|
|
tb.write(1, i, "Name: " & app.client.getId())
|
|
inc i
|
|
tb.write(1, i, fmt"PeerCount: {app.peerCount}")
|
|
inc i
|
|
tb.write(1, i, "Link: ")
|
|
for a in 0..(app.currentInviteLink.len div chunk) :
|
|
tb.write(1+6 , i, app.currentInviteLink[a*chunk ..< min((a+1)*chunk, app.currentInviteLink.len)])
|
|
inc i
|
|
|
|
resetTuiCursor(tb)
|
|
|
|
|
|
proc drawConvoItem(app: ChatApp,
|
|
layout: Pane, convo: ConvoInfo, isSelected: bool = false) =
|
|
|
|
var tb = app.tb
|
|
let xOffset = 3
|
|
let yOffset = 1
|
|
|
|
let dt = convo.lastMsgTime
|
|
|
|
let c = if isSelected: fgMagenta else: fgCyan
|
|
if isSelected:
|
|
tb.setForegroundColor(fgMagenta)
|
|
else:
|
|
tb.setForegroundColor(fgCyan)
|
|
|
|
drawOutline(tb, layout, c)
|
|
tb.write(layout.xStart+xOffset, layout.yStart+yOffset, convo.name)
|
|
tb.write(layout.xStart+xOffset, layout.yStart+yOffset+1,dt.format("yyyy-MM-dd HH:mm:ss"))
|
|
|
|
|
|
proc drawConversationPane( app: ChatApp, layout: Pane) =
|
|
var a = layout
|
|
a.width -= 2
|
|
a.height = 6
|
|
for convo in app.mostRecentConvos():
|
|
drawConvoItem(app, a, convo, app.selectedConv == convo.name)
|
|
a.yStart = a.yStart + a.height
|
|
|
|
|
|
proc splitAt(s: string, index: int): (string, string) =
|
|
let splitIndex = min(index, s.len)
|
|
return (s[0..<splitIndex], s[splitIndex..^1])
|
|
|
|
# Eww
|
|
proc drawMsgPane( app: ChatApp, layout: Pane) =
|
|
var tb = app.tb
|
|
drawOutline(tb, layout, fgYellow)
|
|
|
|
var convo = app.getSelectedConvo()
|
|
|
|
let xStart = layout.xStart+1
|
|
let yStart = layout.yStart+1
|
|
|
|
|
|
let w = layout.width
|
|
let h = layout.height
|
|
|
|
let maxContentWidth = w - 10
|
|
|
|
let xEnd = layout.xStart + maxContentWidth
|
|
let yEnd = layout.yStart + layout.height - 2
|
|
|
|
|
|
tb.setForegroundColor(fgGreen)
|
|
|
|
let x = xStart + 2
|
|
|
|
if not convo.isTooLong:
|
|
var y = yStart
|
|
for i in 0..convo.messages.len-1:
|
|
|
|
let m = convo.messages[i]
|
|
let timeStr = m.timestamp.format("HH:mm:ss")
|
|
var deliveryIcon = " "
|
|
var remainingText = m.content
|
|
|
|
if m.sender == "You":
|
|
tb.setForegroundColor(fgYellow)
|
|
deliveryIcon = if m.isAcknowledged: "✔" else: "◯"
|
|
else:
|
|
tb.setForegroundColor(fgGreen)
|
|
|
|
if y > yEnd:
|
|
convo.isTooLong = true
|
|
app.logMsgs.add(LogEntry(level: "info",ts: now(), msg: fmt" TOO LONG: {convo.name}"))
|
|
|
|
return
|
|
tb.write(x, y, fmt"[{timeStr}] {deliveryIcon} {m.sender}")
|
|
y = y + 1
|
|
|
|
while remainingText.len > 0:
|
|
if y > yEnd:
|
|
convo.isTooLong = true
|
|
app.logMsgs.add(LogEntry(level: "info",ts: now(), msg: fmt" TOO LON2: {convo.name}"))
|
|
|
|
return
|
|
|
|
let (line, remain) = remainingText.splitAt(maxContentWidth)
|
|
remainingText = remain
|
|
|
|
tb.write(x+3, y, line)
|
|
y = y + 1
|
|
y = y + 1
|
|
else:
|
|
var y = yEnd
|
|
for i in countdown(convo.messages.len-1, 0):
|
|
|
|
let m = convo.messages[i]
|
|
let timeStr = m.timestamp.format("HH:mm:ss")
|
|
var deliveryIcon = " "
|
|
var remainingText = m.content
|
|
|
|
if m.sender == "You":
|
|
tb.setForegroundColor(fgYellow)
|
|
deliveryIcon = if m.isAcknowledged: "✔" else: "◯"
|
|
else:
|
|
tb.setForegroundColor(fgGreen)
|
|
|
|
# Print lines in reverse order
|
|
while remainingText.len > 0:
|
|
if (y <= yStart + 1):
|
|
return
|
|
var lineLen = remainingText.len mod maxContentWidth
|
|
if lineLen == 0:
|
|
lineLen = maxContentWidth
|
|
|
|
let line = remainingText[^lineLen..^1]
|
|
remainingText = remainingText[0..^lineLen+1]
|
|
|
|
tb.write(x+3, y, line)
|
|
y = y - 1
|
|
|
|
tb.write(x, y, fmt"[{timeStr}] {deliveryIcon} {m.sender}")
|
|
y = y - 2
|
|
|
|
proc drawMsgInput( app: ChatApp, layout: Pane) =
|
|
var tb = app.tb
|
|
drawOutline(tb, layout, fgCyan)
|
|
|
|
|
|
let inputY = layout.yStart + 2
|
|
let paneStart = layout.xStart
|
|
|
|
# Draw input prompt
|
|
tb.write(paneStart + 1, inputY, " > " & app.inputBuffer, fgWhite)
|
|
|
|
# Draw cursor
|
|
let cursorX = paneStart + 3 + app.inputBuffer.len + 1
|
|
if cursorX < paneStart + layout.width - 1:
|
|
tb.write(cursorX, inputY, "_", fgYellow)
|
|
|
|
discard
|
|
|
|
proc drawFooter( app: ChatApp, layout: Pane) =
|
|
var tb = app.tb
|
|
drawOutline(tb, layout, fgBlue)
|
|
|
|
let xStart = layout.xStart + 3
|
|
let yStart = layout.yStart + 2
|
|
|
|
for i in countdown(app.logMsgs.len - 1, 0):
|
|
let o = app.logMsgs[i]
|
|
let timeStr = o.ts.format("HH:mm:ss")
|
|
let s = fmt"[{timeStr}] {o.level} - {o.msg}"
|
|
app.tb.write( xStart, yStart+i*2, s )
|
|
discard
|
|
|
|
|
|
proc drawModal(app: ChatApp, layout: Pane,
|
|
color: ForegroundColor, bg: BackgroundColor = bgBlack) =
|
|
|
|
var tb = app.tb
|
|
tb.setForegroundColor(color)
|
|
tb.setBackgroundColor(bg)
|
|
for x in layout.xStart..<layout.xStart+layout.width:
|
|
for y in layout.yStart..<layout.yStart+layout.height:
|
|
tb.write(x, y, " ", color)
|
|
|
|
tb.setForegroundColor(fgBlack)
|
|
tb.setBackgroundColor(bgGreen)
|
|
tb.write(layout.xStart + 2, layout.yStart + 2, "Paste Invite")
|
|
|
|
tb.setForegroundColor(fgWhite)
|
|
tb.setBackgroundColor(bgBlack)
|
|
let inputLine = 5
|
|
|
|
for i in layout.xStart+3..<layout.xStart+layout.width-3:
|
|
for y in (layout.yStart + inputLine - 1)..<(layout.yStart+inputLine + 2):
|
|
tb.write(i, y, " ")
|
|
|
|
# Draw input prompt
|
|
tb.write(layout.xStart+5, layout.yStart+inputLine, "> " & app.inputInviteBuffer)
|
|
|
|
# Draw cursor
|
|
let cursorX = layout.xStart+5+1 + app.inputInviteBuffer.len
|
|
if cursorX < terminalWidth() - 1:
|
|
tb.write(cursorX, layout.yStart+inputLine, "_", fgYellow)
|
|
|
|
tb.setForegroundColor(fgBlack)
|
|
tb.setBackgroundColor(bgGreen)
|
|
tb.write(layout.xStart+5, layout.yStart+inputLine+3, "InviteLink: " & app.currentInviteLink)
|
|
|
|
resetTuiCursor(tb)
|
|
|
|
#################################################
|
|
# Input Handling
|
|
#################################################
|
|
|
|
proc gePreviousConv(app: ChatApp): string =
|
|
let convos = app.mostRecentConvos()
|
|
let i = convos.find(app.getSelectedConvo()[])
|
|
|
|
return convos[max(i-1, 0)].name
|
|
|
|
|
|
proc getNextConv(app: ChatApp): string =
|
|
let convos = app.mostRecentConvos()
|
|
var s = ""
|
|
for c in convos:
|
|
s = s & c.name
|
|
|
|
let i = convos.find(app.getSelectedConvo()[])
|
|
app.logMsgs.add(LogEntry(level: "info",ts: now(), msg: fmt"i:{convos[min(i+1, convos.len-1)].isTooLong}"))
|
|
|
|
return convos[min(i+1, convos.len-1)].name
|
|
|
|
|
|
proc handleInput(app: ChatApp, key: Key) {.async.} =
|
|
case key
|
|
of Key.Up:
|
|
app.selectedConv = app.gePreviousConv()
|
|
of Key.Down:
|
|
app.selectedConv = app.getNextConv()
|
|
|
|
of Key.PageUp:
|
|
app.messageScrollOffset = min(app.messageScrollOffset + 5, 0)
|
|
of Key.PageDown:
|
|
app.messageScrollOffset = max(app.messageScrollOffset - 5,
|
|
-(max(0, app.getSelectedConvo().messages.len - 10)))
|
|
of Key.Enter:
|
|
|
|
if app.inviteModal:
|
|
notice "Enter Invite", link= app.inputInviteBuffer
|
|
app.inviteModal = false
|
|
app.isInviteReady = true
|
|
else:
|
|
if app.inputBuffer.len > 0 and app.conversations.len > 0:
|
|
|
|
let sc = app.getSelectedConvo()
|
|
await app.sendMessage(sc, app.inputBuffer)
|
|
|
|
app.inputBuffer = ""
|
|
app.messageScrollOffset = 0 # Auto-scroll to bottom
|
|
of Key.Backspace:
|
|
if app.inputBuffer.len > 0:
|
|
app.inputBuffer.setLen(app.inputBuffer.len - 1)
|
|
of Key.Tab:
|
|
app.inviteModal = not app.inviteModal
|
|
|
|
if app.inviteModal:
|
|
app.currentInviteLink = app.client.createIntroBundle().toLink()
|
|
of Key.Escape, Key.CtrlC:
|
|
quit(0)
|
|
else:
|
|
# Handle regular character input
|
|
let ch = char(key)
|
|
if ch.isAlphaNumeric() or ch in " !@#$%^&*()_+-=[]{}|;':\",./<>?":
|
|
if app.inviteModal:
|
|
app.inputInviteBuffer.add(ch)
|
|
else:
|
|
app.inputBuffer.add(ch)
|
|
|
|
|
|
#################################################
|
|
# Tasks
|
|
#################################################
|
|
|
|
proc appLoop(app: ChatApp, panes: seq[Pane]) : Future[void] {.async.} =
|
|
illwillInit(fullscreen = false)
|
|
# Clear buffer
|
|
while true:
|
|
await sleepAsync(5)
|
|
app.tb.clear()
|
|
|
|
drawStatusBar(app, panes[0], fgBlack, getIdColor(app.client.getId()))
|
|
drawConversationPane(app, panes[1])
|
|
drawMsgPane(app, panes[2])
|
|
|
|
if app.inviteModal:
|
|
drawModal(app, panes[5], fgYellow, bgGreen)
|
|
else:
|
|
drawMsgInput(app, panes[3])
|
|
|
|
drawFooter(app, panes[4])
|
|
|
|
# Draw help text
|
|
app.tb.write(1, terminalHeight()-1, "Tab: Invite Modal | ↑/↓: Select conversation | PgUp/PgDn: Scroll messages | Enter: Send | Esc: Quit", fgGreen)
|
|
|
|
# Display buffer
|
|
app.tb.display()
|
|
|
|
# Handle input
|
|
let key = getKey()
|
|
await handleInput(app, key)
|
|
|
|
if app.isInviteReady:
|
|
|
|
try:
|
|
let sanitized = app.inputInviteBuffer.replace(" ", "").replace("\r","")
|
|
discard await app.client.newPrivateConversation(toBundle(app.inputInviteBuffer.strip()).get())
|
|
|
|
except Exception as e:
|
|
info "bad invite", invite = app.inputInviteBuffer
|
|
app.inputInviteBuffer = ""
|
|
app.isInviteReady = false
|
|
|
|
proc peerWatch(app: ChatApp): Future[void] {.async.} =
|
|
while true:
|
|
await sleepAsync(1000)
|
|
app.peerCount = app.client.ds.getConnectedPeerCount()
|
|
|
|
|
|
#################################################
|
|
# Main
|
|
#################################################
|
|
|
|
proc initChatApp(client: Client): Future[ChatApp] {.async.} =
|
|
|
|
var app = ChatApp(
|
|
client: client,
|
|
tb: newTerminalBuffer(terminalWidth(), terminalHeight()),
|
|
conversations: initTable[string, ConvoInfo](),
|
|
selectedConv: "Bob",
|
|
inputBuffer: "",
|
|
scrollOffset: 0,
|
|
messageScrollOffset: 0,
|
|
isInviteReady: false,
|
|
peerCount: -1,
|
|
logMsgs: @[]
|
|
)
|
|
|
|
app.setupChatSdk()
|
|
await app.client.start()
|
|
|
|
|
|
# Add some sample conversations with messages
|
|
var conv1 = ConvoInfo(name: "ReadMe", messages: @[])
|
|
conv1.addMessage("","Bob", "TODO")
|
|
app.conversations[conv1.name] = conv1
|
|
|
|
return app
|
|
|
|
|
|
proc main*() {.async.} =
|
|
|
|
let args = getCmdArgs()
|
|
let client = await createChatClient(args.username)
|
|
var app = await initChatApp(client)
|
|
|
|
let tasks: seq[Future[void]] = @[
|
|
appLoop(app, getPanes()),
|
|
peerWatch(app)
|
|
]
|
|
|
|
discard await allFinished(tasks)
|
|
|
|
when isMainModule:
|
|
waitFor main()
|
|
|
|
# this is not nim code |