New stuff (and notices)

README

@@ -1,6 +1,10 @@
 MOONTALK
 
-See client/README
+See client/README for the clients
 
-Licensing...
-Everything is licensed under GPLv3 or GPLv3+ under the respective owners.
+See bots/README for the bots
+
+See server/README for the servers
+
+Licensing... Everything unless otherwise specified is licensed
+under GPLv3 or GPLv3+ under the respective owners.

bots/README

@@ -0,0 +1,4 @@
+Bots.
+
+There are exactly two currently, both housed within the moonchat directory.
+See moonchat/README.

bots/moonchat/README

@@ -0,0 +1,15 @@
+Some rephrased notes from the author:
+
+Use torify, obviously,
+
+-- RUNNING --
+
+scramble-bot:
+  python3 scramble-bot.py < /usr/share/dict/american-english
+
+  the !scramble command should now work.
+
+who-bot:
+  python3 who-bot.py
+
+  [who] [whoami]

bots/moonchat/moonchat.py

@@ -0,0 +1,98 @@
+import asyncio
+import re
+import typing
+
+
+server_message_regex = re.compile(r"^(?P<nickname>[\w\s]+):\s*(?P<content>.*)$")
+
+
+class MoonchatMessage(typing.NamedTuple):
+    nickname: str
+    content: str
+
+
+class MessageDecodeError(ValueError):
+    pass
+
+
+class Moonchat:
+    def __init__(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, encoding: str):
+        self.reader = reader
+        self.writer = writer
+        self.encoding = encoding
+        self.closed = False
+
+    def close(self):
+        if self.closed:
+            return
+        self.closed = True
+        if not self.writer.is_closing():
+            if self.writer.can_write_eof():
+                self.writer.write_eof()
+            self.writer.close()
+
+    @staticmethod
+    async def connect(ip: str, port: int, encoding='ascii', **kwargs):
+        """Provide the hostname, port and optional arguments to open_connection."""
+        streams = await asyncio.open_connection(ip, port, **kwargs)
+        return Moonchat(*streams, encoding=encoding) if encoding else Moonchat(*streams)
+
+    def encode_message(self, message: str) -> bytes:
+        """Return encoded raw data with trailing newline if required."""
+        return (message.removesuffix('\n')+'\n').encode(self.encoding)
+
+    def decode_message(self, data: bytes) -> MoonchatMessage:
+        """Return decoded raw data without trailing newlines."""
+        unparsed = (data.decode(self.encoding)).strip()
+        regex_match = server_message_regex.match(unparsed)
+        if not regex_match:
+            raise ValueError("cannot decode malformed message: " + unparsed)
+        return MoonchatMessage(**regex_match.groupdict())
+
+    async def send_message(self, message: str) -> bool:
+        """Sends string to chat. Return whether successful."""
+        encoded_message = self.encode_message(message)
+        return await self.send_message_raw(encoded_message)
+
+    async def send_message_raw(self, message: bytes | bytearray | memoryview) -> bool:
+        """Send raw data straight to the server if you feel like it. Return True if successful."""
+        if self.closed:
+            return False
+        if self.writer.is_closing():
+            self.close()
+            return False
+        self.writer.write(message)
+        await self.writer.drain()
+        return True
+
+    async def recieve_message_raw(self) -> bytes | None:
+        """Retrieve the next line from the server, or None if there are no more messages."""
+        if self.closed:
+            return None
+        line = await self.reader.readline()
+        if b'\n' not in line: # partial reads mean we're out of data
+            self.close()
+            return None
+        return line
+
+    async def recieve_message(self) -> MoonchatMessage | None:
+        """Retrieve the next message from the server."""
+        raw_message = await self.recieve_message_raw()
+        return self.decode_message(raw_message) if raw_message else None
+
+    async def raw_messages(self):
+        """Yield raw unencoded messages until connection is closed."""
+        while not self.closed:
+            if message := await self.recieve_message_raw():
+                yield message
+
+    async def messages(self, ignore_invalid=False):
+        """Yield messages until the connection is closed"""
+        while not self.closed:
+            try:
+                message = await self.recieve_message()
+            except MessageDecodeError as err:
+                if not ignore_invalid:
+                    raise err
+            if message:
+                yield message

bots/moonchat/scramble-bot.py

@@ -0,0 +1,58 @@
+# TODO: add a fucking scoreboard or something? this is a copy of a Espernet bot.
+from moonchat import *
+import sys
+import random
+import io
+
+class Bot:
+    def __init__(self, chat: Moonchat, words: list[str]):
+        self.chat = chat
+        self.words = words
+
+    async def next_winner(self, word: str, limit: float):
+        try:
+            async with asyncio.timeout(limit):
+                async for message in self.chat.messages():
+                    if word in message.content.lower():
+                        return message
+        except TimeoutError:
+            return None
+
+    async def handle_incoming(self):
+        limit = 60
+        async for message in self.chat.messages():
+            if message.nickname == 'Server':
+                continue # ignore the server
+            if "!scramble" not in message.content:
+                continue
+            print(f"GAME REQUESTED: {message=}")
+            selected_word = random.choice(self.words)
+            scrambled_word = ''.join(random.sample(selected_word, len(selected_word)))
+            print(f"GAME START: {scrambled_word} is {selected_word}")
+            await self.chat.send_message(f"Unscramble in {limit} seconds to win! The word is: {scrambled_word}.")
+            winner = await self.next_winner(selected_word, limit)
+            print(f"GAME OVER: {winner=}")
+            if winner:
+                await self.chat.send_message(f"The word was {selected_word}. {winner.nickname} wins!")
+            else:
+                await self.chat.send_message(f"Time's up! The word was {selected_word}. No one wins.")
+
+async def main(words: list[str]):
+    chat = await Moonchat.connect("7ks473deh6ggtwqsvbqdurepv5i6iblpbkx33b6cydon3ajph73sssad.onion", 50000)
+    bot = Bot(chat, words)
+    await chat.send_message("To play scramble say: !scramble")
+    await bot.handle_incoming()
+
+
+def load_words(file: io.TextIOBase):
+    for line in file:
+        line = line.strip().lower()
+        if "'" not in line and len(line) == 5:
+            yield line
+
+
+if __name__ == "__main__":
+    import asyncio
+    words = list(load_words(sys.stdin))
+    print(f"Loaded {len(words)} words")
+    asyncio.run(main(words))

bots/moonchat/who-bot.py

@@ -0,0 +1,82 @@
+import re
+from datetime import datetime, timedelta
+from moonchat import *
+
+class Bot:
+    def __init__(self, chat: Moonchat, command_matcher: re.Pattern):
+        self.chat = chat
+        self.command_matcher = command_matcher
+        self.commands = dict()
+        self.last_annoyed = datetime.now()
+        self.seen = dict()
+
+    async def handle_incoming(self):
+        async for message in self.chat.messages():
+            now = datetime.now()
+            if message.nickname == 'Server':
+                continue # ignore the server
+            last_seen = self.seen.get(message.nickname, None)
+            if last_seen:
+                seen_delta = now - last_seen
+                if seen_delta > timedelta(hours=2):
+                    last_seen = None
+            if not last_seen:
+                if (now - self.last_annoyed) > timedelta(minutes=10):
+                    await self.chat.send_message(f"hello {message.nickname}! i am a robot. say [help]")
+                    self.last_annoyed = now
+            self.seen[message.nickname] = datetime.now()
+            match = self.command_matcher.search(message.content)
+            if not match:
+                continue # ignore not our messages
+            command = match.groupdict().get('command', None)
+            if not command:
+                continue # ????
+            split = command.split()
+            if not len(split):
+                continue # ????????????
+            exector = split[0]
+            command_function = self.commands.get(exector, None)
+            if command_function:
+                await command_function(self, message, split)
+            else:
+                await self.chat.send_message(f"{message.nickname}: sorry that's not a valid command")
+
+async def who_command(bot: Bot, message: MoonchatMessage, args):
+    """See recent users"""
+    now = datetime.now()
+    result = "Users from last 1hour: "
+    for username, last_seen in bot.seen.items():
+        delta: timedelta = (now - last_seen)
+        if delta < timedelta(hours=1):
+            minutes, seconds = divmod(delta.seconds, 60)
+            result += f"{username}({minutes}m{seconds}s), "
+    await bot.chat.send_message(result)
+
+async def whoami(bot: Bot, message: MoonchatMessage, args):
+    """Print your nickname"""
+    await bot.chat.send_message(message.nickname)
+
+async def help(bot: Bot, message: MoonchatMessage, args):
+    command = args[1] if len(args) > 1 else None
+    command_function = bot.commands.get(command, None)
+    if command_function:
+        await bot.chat.send_message(f"{command}: {command_function.__doc__}")
+        return
+    command_list = ', '.join(bot.commands.keys())
+    await bot.chat.send_message(f"Commands available: {command_list}")
+
+matcher = re.compile(r"\[(?P<command>[\w\s]+)\]")
+
+async def main():
+    chat = await Moonchat.connect("7ks473deh6ggtwqsvbqdurepv5i6iblpbkx33b6cydon3ajph73sssad.onion", 50000)
+    bot = Bot(chat, matcher)
+    bot.commands["help"] = help
+    bot.commands['who'] = who_command
+    bot.commands['whoami'] = whoami
+    await chat.send_message("i am a robot! do [help]")
+    await bot.handle_incoming()
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

client/moontalk-cli.c

@@ -115,7 +115,7 @@ void clearline(WINDOW * w, int y) {
 void sanitize(char * buf, size_t rem) {
 	char * base = buf;
 	buf += rem;
-	while (buf - base) {
+	while (*buf && buf - base) {
 		if (*buf < ' ' || *buf > '~') {
 			if (*buf != '\n')
 			{ *buf = '!'; }
@@ -163,6 +163,16 @@ int main (int argc, char ** argv) {
 	nodelay(stdscr, TRUE);
 	ESCDELAY = 0;
 	curs_set(0);
+	if (has_colors() && can_change_color()) {
+		short bg, fg;
+		/* leaks memory :( */
+		start_color();
+		for (bg = 0; bg < 8; ++bg) {
+			for (fg = 0; fg < 8; ++fg) {
+				init_pair(16 + fg + (bg * 8), fg, bg);
+			}
+		}
+	}
 	clear();
 
 	#define WINCOUNT 3
@@ -238,9 +248,11 @@ hardrefresh:
 			}
 			else if ((ch > 31 && ch < 127)) {
 				if (sendlen + 1 < SENDMAX)
-				{ sendbuf[edit++] = ch; ++sendlen; }
-				/* mvwchgat(input, 2, sendlen - 1, 1, A_REVERSE, 0, NULL); */
-				mvwaddnstr(input, 2, 0, sendbuf, sendlen);
+				{
+					memmove(sendbuf + edit + 1, sendbuf + edit, sendlen - edit);
+					sendbuf[edit++] = ch; ++sendlen;
+				}
+				inputrefresh = 1;
 			}
 			else if (ch == '\n') {
 				if (sendlen == sendminlen)
@@ -254,63 +266,73 @@ hardrefresh:
 				} else {
 					mvwprintw(input, 1, 0, "message failed: %s", strerror(errno));
 				}
-				/* mvwaddch(0, sendminlen, ' '); */
-				/* mvwchgat(input, 2, 0, 1, A_STANDOUT, 0, NULL); */
 				bodyrefresh = inputrefresh = 1;
-				clearline(input, 2);
 				edit = sendlen = sendminlen;
 			}
 			else if (ch == BACKSPACE || ch == C_H) {
 				inputrefresh = 1;
-				clearline(input, 2);
-				if (sendlen - 1 >= sendminlen)
-				{ mvwaddch(input, 2, --sendlen, ' '); --edit; }
-				mvwaddnstr(input, 2, 0, sendbuf, sendlen);
-				wmove(input, 2, sendlen);
+				if (sendlen - 1 >= sendminlen && edit - 1 >= sendminlen)
+				{
+					memmove(sendbuf + edit - 1, sendbuf + edit, sendlen - edit);
+					--sendlen; --edit;
+				}
+				inputrefresh = 1;
 			}
 			else if (ch == KEY_LEFT) {
-				/* if (edit > sendminlen) { --edit; } */
+				if (edit > sendminlen) { --edit; }
 			}
 			else if (ch == KEY_RIGHT) {
-				/* if (edit - 1 < sendlen) { ++edit; } */
+				if (edit < sendlen) { ++edit; }
 			}
 			else if (ch == KEY_DOWN) {
 				mvwprintw(input, 1, 150, "scroll down %ld", offlen);
-				while (off - recvbuf < RECVMAX && *off != '\n') { ++off; }
+				while ((size_t)(off - recvbuf) < recvlen && *off != '\n') { ++off; }
 				if (*off == '\n') { ++off; }
 				wclear(body);
 				bodyrefresh = 1;
 			}
 			else if (ch == KEY_UP) {
 				mvwprintw(input, 1, 150, "scroll up   %ld", offlen);
-				while (off - recvbuf > 0) { --off; }
-				/* wclear(body); */
+				if (off - 2 - recvbuf > 0) { off -= 2; }
+				while (off - recvbuf > 0 && *off != '\n') { --off; }
+				if (*off == '\n') { ++off; }
 				bodyrefresh = 1;
 			}
 			else if (ch == C_W) {
-				while (sendlen > sendminlen && ispunct(sendbuf[sendlen - 1])) { --sendlen; }
-				while (sendlen > sendminlen && isspace(sendbuf[sendlen - 1])) { --sendlen; }
-				while (sendlen > sendminlen && isalnum(sendbuf[sendlen - 1])) { --sendlen; }
+				i = edit;
+				while (i > sendminlen && isspace(sendbuf[i - 1])) { --i; }
+				while (i > sendminlen && !isspace(sendbuf[i - 1])) { --i; }
+				if (i == edit) { continue; }
+				mvwprintw(input, 1, 200, "diff:%ld", sendlen - edit);
+				/* memmove(sendbuf + i, sendbuf + edit, sendlen - edit); */
+				/* sendlen -= edit; */
+				/* edit = i; */
+				/* mvwprintw(input, 1, 200, "i:%ld:%ld:sendl:%3ld", */
+				/* i - sendminlen, (sendbuf + edit) - (sendbuf + i), sendlen - sendminlen); */
 				inputrefresh = 1;
-				clearline(input, 2);
 			}
-
 		}
 		/* update and rendering */
-		if (ct % frame == 0 || inputrefresh || bodyrefresh) {
-			UPDATE_TIME();
-			/* wclear(input); */
+		if (inputrefresh) {
+			clearline(input, 2);
 			mvwaddnstr(input, 2, 0, sendbuf, sendlen);
+			mvwchgat(input, 2, edit, 1, A_REVERSE, 0, NULL);
+		}
 
+		if (ct % frame == 0) {
+			UPDATE_TIME();
+		}
+
+		if (ct % frame == 0 || bodyrefresh) {
 			ret = recv(sockfd, recvbuf + recvlen, RECVMAX - recvlen, MSG_DONTWAIT);
-			if (errno != EAGAIN)
+			if (errno && errno != EAGAIN)
 			{ mvwaddstr(input, 1, 0, strerror(errno)); }
 			if (bodyrefresh) {
 				bodyrefresh = 0;
-				if (!(ret > -1))
+				if (!(ret > 0))
 				goto _bodyrefresh;
 			}
-			if (ret > -1) {
+			if (ret > 0) {
 				sanitize(recvbuf + recvlen, ret);
 				if (ret + recvlen < RECVMAX)
 				{

server/README

@@ -0,0 +1,9 @@
+Servers.
+
+There is one real server, written in the ever brilliant Forth, is housed
+within eventloop-server-experiment/, which is the origin of all things
+Moontalk. OP, who created it, is a legend and killed a dragon using only
+Forth and Sockets.
+
+blackhole/ just eats sent messages, made for client feedback testing
+only, stolen from beej.