@bruggmann._/ccli 1.0.0

package/README.md

@@ -0,0 +1,64 @@
+# ccli — Chat Command Line Interface
+
+A terminal-based real-time chat built with TypeScript and WebSockets.
+
+## Features
+
+- Real-time messaging via WebSockets
+- Multiple channels with persistent message history
+- Live nickname changes
+- Interactive menu with ASCII art
+- Input validation with Zod
+
+## Project Structure
+
+```
+packages/
+  shared/   → Schemas, types, and utilities shared between client and server
+  server/   → WebSocket server (state management, command handling)
+  client/   → Terminal client (UI, menus, chat prompt)
+```
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js
+- pnpm (or npm, yarn, etc.)
+
+### Install
+
+```bash
+pnpm install
+```
+
+### Run
+
+Start the server:
+
+```bash
+pnpm server
+```
+
+In another terminal, start one or more clients:
+
+```bash
+pnpm client
+```
+
+## Chat Commands
+
+| Command            | Description                                      |
+| ------------------ | ------------------------------------------------ |
+| `/home`            | Leave the current channel and return to the menu |
+| `/join <channel>`  | Join another channel (creates it if needed)      |
+| `/nick <nickname>` | Change your nickname                             |
+| `/exit`            | Exit the program                                 |
+
+## Tech Stack
+
+- **TypeScript** — Language
+- **ws** — WebSocket server and client
+- **Zod** — Schema validation
+- **@inquirer/prompts** — Interactive terminal prompts
+- **nodemon** — Dev server auto-restart

package/dist/packages/client/src/chatPrompt.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatPrompt = createChatPrompt;
+const readline_1 = __importDefault(require("readline"));
+function createChatPrompt() {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+    let currentPrompt = '';
+    const setPrompt = (prompt) => {
+        currentPrompt = prompt.endsWith(' ') ? prompt : prompt + ' ';
+        rl.setPrompt(currentPrompt);
+    };
+    const readLine = (prompt) => {
+        setPrompt(prompt);
+        readline_1.default.clearLine(process.stdout, 0);
+        readline_1.default.cursorTo(process.stdout, 0);
+        process.stdout.write(currentPrompt);
+        return new Promise(resolve => {
+            rl.once('line', line => resolve(line.trim()));
+        });
+    };
+    const printLine = (line) => {
+        readline_1.default.clearLine(process.stdout, 0);
+        readline_1.default.cursorTo(process.stdout, 0);
+        process.stdout.write(line + '\n');
+        rl.setPrompt(currentPrompt);
+        rl.prompt();
+    };
+    const updatePrompt = (prompt) => {
+        setPrompt(prompt);
+        readline_1.default.clearLine(process.stdout, 0);
+        readline_1.default.cursorTo(process.stdout, 0);
+        rl.prompt();
+    };
+    const close = () => {
+        process.stdin.removeAllListeners('keypress');
+        process.stdin.resume();
+    };
+    return { readLine, printLine, updatePrompt, close };
+}

package/dist/packages/client/src/colors.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignColor = assignColor;
+exports.colorize = colorize;
+exports.resetColors = resetColors;
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+const PALETTE = [
+    `${ESC}33m`, // yellow
+    `${ESC}35m`, // magenta
+    `${ESC}32m`, // green
+    `${ESC}91m`, // bright red
+    `${ESC}94m`, // bright blue
+    `${ESC}93m`, // bright yellow
+    `${ESC}95m`, // bright magenta
+    `${ESC}92m`, // bright green
+];
+const nickColors = new Map();
+let nextIndex = 0;
+function nextColor() {
+    const color = PALETTE[nextIndex];
+    nextIndex = (nextIndex + 1) % PALETTE.length;
+    return color;
+}
+function assignColor(nickname) {
+    if (!nickColors.has(nickname)) {
+        nickColors.set(nickname, nextColor());
+    }
+}
+function colorize(nickname) {
+    const color = nickColors.get(nickname) ?? nextColor();
+    if (!nickColors.has(nickname)) {
+        nickColors.set(nickname, color);
+    }
+    return `${color}${nickname}${RESET}`;
+}
+function resetColors() {
+    nickColors.clear();
+    nextIndex = 0;
+}

package/dist/packages/client/src/index.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const socket_1 = require("./socket");
+const ui_1 = require("./ui");
+const schemas_1 = require("../../shared/src/schemas");
+const utils_1 = require("../../shared/src/utils");
+const chatPrompt_1 = require("./chatPrompt");
+const render_1 = require("./render");
+const menu_1 = require("./menu");
+const input_1 = require("./input");
+const colors_1 = require("./colors");
+function isMenuMessage(msg) {
+    return msg.type === 'menu';
+}
+socket_1.socket.on('open', () => {
+    main().catch(err => {
+        console.error(err);
+        process.exit(1);
+    });
+});
+async function main() {
+    (0, render_1.clearScreen)();
+    setupMessageHandler();
+    const nickname = await getNickname();
+    let menu = await setNicknameAndGetMenu(nickname);
+    while (true) {
+        const action = await (0, menu_1.showMenu)(menu.payload.users, menu.payload.channels);
+        if (action.type === 'exit')
+            exitApp();
+        (0, socket_1.sendJson)(socket_1.socket, { type: 'join', payload: { channel: action.channel } });
+        (0, render_1.clearScreen)();
+        (0, ui_1.endInteractivePrompt)();
+        const reason = await chatLoop(nickname);
+        if (reason === 'exit')
+            exitApp();
+        (0, socket_1.sendJson)(socket_1.socket, { type: 'menu_request' });
+        menu = await (0, socket_1.waitForServerMessage)(socket_1.socket, isMenuMessage);
+    }
+}
+let onNickChanged = null;
+let selfNick = '';
+function setupMessageHandler() {
+    (0, socket_1.onServerMessage)(socket_1.socket, msg => {
+        switch (msg.type) {
+            case 'message':
+                (0, ui_1.printLine)(`[${(0, colors_1.colorize)(msg.payload.from)}] ${msg.payload.text}`);
+                break;
+            case 'channel_history':
+                (0, render_1.clearScreen)();
+                (0, colors_1.resetColors)();
+                (0, colors_1.assignColor)(selfNick);
+                (0, ui_1.printLines)(msg.payload.messages.map(m => `[${(0, colors_1.colorize)(m.from)}] ${m.message}`));
+                break;
+            case 'nick_changed':
+                onNickChanged?.(msg.payload.oldNick, msg.payload.newNick);
+                break;
+            case 'system':
+                (0, ui_1.printLine)(render_1.c.cyan(`* ${msg.payload.message} *`));
+                break;
+            case 'error':
+                (0, ui_1.printLine)(`Error: ${msg.payload.message}`);
+                break;
+        }
+    });
+}
+function exitApp() {
+    socket_1.socket.close();
+    process.exit(0);
+}
+async function getNickname() {
+    return (0, input_1.prompt)('Enter your nickname:', {
+        validate: async (value) => {
+            const nickname = value.trim();
+            const format = schemas_1.NicknameSchema.safeParse(nickname);
+            if (!format.success)
+                return (0, utils_1.zodErrorMessage)(format.error);
+            try {
+                const available = await checkNicknameAvailable(nickname);
+                return available ? true : 'Nickname already taken';
+            }
+            catch {
+                return 'Could not check nickname availability. Try again.';
+            }
+        },
+    });
+}
+async function checkNicknameAvailable(nickname) {
+    (0, socket_1.sendJson)(socket_1.socket, { type: 'check_nick', payload: { nickname } });
+    const reply = await (0, socket_1.waitForServerMessage)(socket_1.socket, m => m.type === 'nick_check' && m.payload.nickname === nickname, { timeoutMs: 5000 });
+    if (reply.type !== 'nick_check')
+        throw new Error('Unexpected server reply');
+    return reply.payload.available;
+}
+async function setNicknameAndGetMenu(nickname) {
+    (0, socket_1.sendJson)(socket_1.socket, { type: 'set_nick', payload: { nickname } });
+    return (0, socket_1.waitForServerMessage)(socket_1.socket, isMenuMessage, { timeoutMs: 5000 });
+}
+async function chatLoop(nickname) {
+    let currentNick = nickname;
+    selfNick = nickname;
+    const chat = (0, chatPrompt_1.createChatPrompt)();
+    (0, ui_1.setRealtimePrinter)(chat.printLine);
+    onNickChanged = (oldNick, newNick) => {
+        if (oldNick === currentNick) {
+            currentNick = newNick;
+            selfNick = newNick;
+            chat.updatePrompt(`[${(0, colors_1.colorize)(currentNick)}]> `);
+        }
+        else {
+            (0, ui_1.printLine)(render_1.c.cyan(`* ${oldNick} is now ${newNick} *`));
+        }
+    };
+    try {
+        while (true) {
+            const text = await chat.readLine(`[${(0, colors_1.colorize)(currentNick)}]> `);
+            if (!text)
+                continue;
+            if (text.startsWith('/')) {
+                const [cmd, ...args] = text.slice(1).split(' ');
+                switch (cmd) {
+                    case 'home':
+                        (0, socket_1.sendJson)(socket_1.socket, { type: 'leave_channel' });
+                        return 'home';
+                    case 'join':
+                        (0, socket_1.sendJson)(socket_1.socket, {
+                            type: 'join',
+                            payload: { channel: args[0] },
+                        });
+                        continue;
+                    case 'nick':
+                        (0, socket_1.sendJson)(socket_1.socket, {
+                            type: 'set_nick',
+                            payload: { nickname: args[0] },
+                        });
+                        continue;
+                    case 'exit':
+                        return 'exit';
+                }
+            }
+            (0, socket_1.sendJson)(socket_1.socket, { type: 'message', payload: { text } });
+        }
+    }
+    finally {
+        onNickChanged = null;
+        (0, ui_1.setRealtimePrinter)(null);
+        chat.close();
+    }
+}

package/dist/packages/client/src/input.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = prompt;
+const ui_1 = require("./ui");
+const prompts_1 = require("@inquirer/prompts");
+const render_1 = require("./render");
+async function prompt(text, options) {
+    (0, ui_1.beginInteractivePrompt)();
+    try {
+        return (await (0, prompts_1.input)({
+            message: text,
+            validate: options?.validate,
+            theme: render_1.promptTheme,
+        })).trim();
+    }
+    finally {
+        (0, ui_1.endInteractivePrompt)();
+    }
+}

package/dist/packages/client/src/menu.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showMenu = showMenu;
+const ui_1 = require("./ui");
+const render_1 = require("./render");
+const prompts_1 = require("@inquirer/prompts");
+const BOX_W = 45;
+const hr = render_1.c.gray('─'.repeat(BOX_W));
+const hrDouble = render_1.c.gray('═'.repeat(BOX_W));
+function header(title) {
+    console.log(hrDouble);
+    console.log(render_1.c.bold(render_1.c.white((0, render_1.centerText)(title, BOX_W))));
+    console.log(hrDouble);
+}
+async function showMenu(users, channels) {
+    (0, ui_1.setRealtimePrinter)(null);
+    while (true) {
+        (0, render_1.clearScreen)();
+        console.log(render_1.asciiArt);
+        console.log();
+        await (0, render_1.sleep)(400);
+        header('M E N U');
+        await (0, render_1.sleep)(100);
+        console.log();
+        printUsers(users);
+        (0, ui_1.beginInteractivePrompt)();
+        const selection = await (0, prompts_1.select)({
+            message: '',
+            choices: buildChoices(channels),
+            theme: render_1.promptTheme,
+        }).finally(() => (0, ui_1.endInteractivePrompt)());
+        if (selection.type !== 'commands')
+            return selection;
+        await showCommandsScreen();
+    }
+}
+function buildChoices(channels) {
+    return [
+        new prompts_1.Separator(render_1.c.gray('\n   ┌── Channels ──────────────────┐')),
+        ...channels.map(channel => ({
+            name: render_1.c.cyan(`   #${channel}`),
+            value: { type: 'join', channel },
+        })),
+        new prompts_1.Separator(render_1.c.gray('  └──────────────────────────────┘')),
+        new prompts_1.Separator(''),
+        { name: render_1.c.yellow('  ? Commands'), value: { type: 'commands' } },
+        { name: render_1.c.magenta('  ✕ Exit'), value: { type: 'exit' } },
+    ];
+}
+async function showCommandsScreen() {
+    (0, render_1.clearScreen)();
+    console.log();
+    header('C O M M A N D S');
+    console.log();
+    console.log(render_1.c.gray('  Available while in a channel:'));
+    console.log();
+    printCmd('/home', 'return to menu');
+    printCmd('/join <channel>', 'join/create a channel');
+    printCmd('/nick <nickname>', 'change your nickname');
+    printCmd('/exit', 'exit program');
+    console.log();
+    console.log(hr);
+    console.log();
+    (0, ui_1.beginInteractivePrompt)();
+    await (0, prompts_1.select)({
+        message: '',
+        choices: [{ name: render_1.c.gray('← Back to menu'), value: true }],
+        theme: render_1.promptTheme,
+    }).finally(() => (0, ui_1.endInteractivePrompt)());
+}
+function printCmd(cmd, desc) {
+    console.log(`  ${render_1.c.cyan(cmd.padEnd(20))} ${render_1.c.dim(desc)}`);
+}
+function printUsers(users) {
+    console.log(render_1.c.bold('  Online'));
+    console.log(hr);
+    if (users.length === 0) {
+        console.log(render_1.c.dim('    (none)'));
+    }
+    else {
+        for (const user of users) {
+            console.log(`    ${render_1.c.green('●')} ${user}`);
+        }
+    }
+    console.log();
+}

package/dist/packages/client/src/render.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asciiArt = exports.c = exports.promptTheme = void 0;
+exports.clearScreen = clearScreen;
+exports.sleep = sleep;
+exports.centerText = centerText;
+exports.promptTheme = {
+    prefix: '',
+};
+function clearScreen() {
+    process.stdout.write('\x1Bc');
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ── ANSI helpers ──
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+exports.c = {
+    reset: RESET,
+    bold: (s) => `${ESC}1m${s}${RESET}`,
+    dim: (s) => `${ESC}2m${s}${RESET}`,
+    cyan: (s) => `${ESC}36m${s}${RESET}`,
+    green: (s) => `${ESC}32m${s}${RESET}`,
+    yellow: (s) => `${ESC}33m${s}${RESET}`,
+    magenta: (s) => `${ESC}35m${s}${RESET}`,
+    gray: (s) => `${ESC}90m${s}${RESET}`,
+    white: (s) => `${ESC}97m${s}${RESET}`,
+};
+function centerText(text, width) {
+    const pad = Math.max(0, Math.floor((width - text.length) / 2));
+    return ' '.repeat(pad) + text;
+}
+// ── ASCII art ──
+const artColor = `${ESC}9${Math.floor(Math.random() * 8)}m`;
+const dim = `${ESC}2m`;
+const normal = `${ESC}22m`;
+const cloudChars = ['·', '.', ':', '*', '~', '^', '`', '°', '•'];
+function cloudSegment(length, density = 0.12) {
+    let out = '';
+    for (let i = 0; i < length; i++) {
+        out +=
+            Math.random() < density
+                ? cloudChars[Math.floor(Math.random() * cloudChars.length)]
+                : ' ';
+    }
+    return out;
+}
+const artLines = [
+    '           ______   ______   __        ____',
+    '          / ____/  / ____/  / /       /  _/',
+    '         / /      / /      / /        / /  ',
+    '        / /___   / /___   / /___    _/ /   ',
+    '        \\____/   \\____/  /_____/   /___/  ',
+];
+const leftPad = 10;
+const rightPad = 10;
+const maxLen = Math.max(...artLines.map(l => l.length));
+const topBottom = [
+    cloudSegment(leftPad + maxLen + rightPad, 0.08),
+    cloudSegment(leftPad + maxLen + rightPad, 0.06),
+];
+const framed = artLines.map(line => {
+    const left = cloudSegment(leftPad);
+    const right = cloudSegment(rightPad);
+    const padded = line.padEnd(maxLen, ' ');
+    return `${dim}${left}${normal}${padded}${dim}${right}${normal}`;
+});
+exports.asciiArt = `${artColor}${dim}${topBottom.join('\n')}${normal}\n` +
+    `${framed.join('\n')}\n` +
+    `${dim}${topBottom.slice().reverse().join('\n')}${RESET}`;

package/dist/packages/client/src/socket.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socket = void 0;
+exports.sendJson = sendJson;
+exports.onServerMessage = onServerMessage;
+exports.waitForServerMessage = waitForServerMessage;
+const schemas_1 = require("../../shared/src/schemas");
+const ws_1 = require("ws");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+exports.socket = new ws_1.WebSocket(process.env.SERVER_URL);
+function sendJson(socket, msg) {
+    socket.send(JSON.stringify(msg));
+}
+function onServerMessage(socket, handler) {
+    socket.on('message', data => {
+        const msg = parseServerMessage(data.toString());
+        if (msg)
+            handler(msg);
+    });
+}
+function waitForServerMessage(socket, predicate, options) {
+    const timeoutMs = options?.timeoutMs ?? 10000;
+    return new Promise((resolve, reject) => {
+        const onMessage = (data) => {
+            const msg = parseServerMessage(data.toString());
+            if (!msg || !predicate(msg))
+                return;
+            cleanup();
+            resolve(msg);
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error('Timeout waiting for server message'));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            socket.off('message', onMessage);
+        };
+        socket.on('message', onMessage);
+    });
+}
+function parseServerMessage(text) {
+    try {
+        const result = schemas_1.ServerMessageSchema.safeParse(JSON.parse(text));
+        return result.success ? result.data : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/packages/client/src/ui.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beginInteractivePrompt = beginInteractivePrompt;
+exports.endInteractivePrompt = endInteractivePrompt;
+exports.setRealtimePrinter = setRealtimePrinter;
+exports.printLine = printLine;
+exports.printLines = printLines;
+let interactivePromptActive = false;
+let queuedLines = [];
+let realtimePrinter = null;
+function beginInteractivePrompt() {
+    interactivePromptActive = true;
+}
+function endInteractivePrompt() {
+    interactivePromptActive = false;
+    flushQueuedLines();
+}
+function setRealtimePrinter(printer) {
+    realtimePrinter = printer;
+    flushQueuedLines();
+}
+function printLine(line) {
+    if (realtimePrinter) {
+        realtimePrinter(line);
+    }
+    else if (interactivePromptActive) {
+        queuedLines.push(line);
+    }
+    else {
+        console.log(line);
+    }
+}
+function printLines(lines) {
+    lines.forEach(printLine);
+}
+function flushQueuedLines() {
+    if (queuedLines.length === 0 || interactivePromptActive)
+        return;
+    const lines = queuedLines;
+    queuedLines = [];
+    const print = realtimePrinter ?? console.log;
+    lines.forEach(print);
+}

package/dist/packages/server/src/commands.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMessage = handleMessage;
+const schemas_1 = require("../../shared/src/schemas");
+const utils_1 = require("../../shared/src/utils");
+const state_1 = require("./state");
+function handleMessage(client, text) {
+    const msg = parseClientMessage(client, text);
+    if (!msg)
+        return;
+    switch (msg.type) {
+        case 'check_nick': {
+            const available = !state_1.state.listUsers().includes(msg.payload.nickname);
+            client.send({
+                type: 'nick_check',
+                payload: { nickname: msg.payload.nickname, available },
+            });
+            break;
+        }
+        case 'set_nick': {
+            const nick = msg.payload.nickname;
+            const oldNick = client.nickname;
+            if (state_1.state.listUsers().includes(nick) && oldNick !== nick) {
+                sendError(client, 'Nickname already taken');
+                return;
+            }
+            if (oldNick) {
+                state_1.state.changeNickname(client, nick);
+                const nickChangedMsg = {
+                    type: 'nick_changed',
+                    payload: { oldNick, newNick: nick },
+                };
+                client.send(nickChangedMsg);
+                if (client.currentChannel) {
+                    state_1.state.broadcastToChannel(client.currentChannel, nickChangedMsg, nick);
+                }
+            }
+            else {
+                client.nickname = nick;
+                state_1.state.addClient(client);
+                state_1.state.broadcastSystem({
+                    type: 'system',
+                    payload: { message: `${nick} connected` },
+                }, nick);
+            }
+            sendMenu(client);
+            break;
+        }
+        case 'join': {
+            const oldChannel = client.currentChannel;
+            if (oldChannel) {
+                state_1.state.broadcastToChannel(oldChannel, {
+                    type: 'system',
+                    payload: { message: `${client.nickname} left #${oldChannel}` },
+                });
+            }
+            state_1.state.joinChannel(client, msg.payload.channel);
+            state_1.state.broadcastToChannel(msg.payload.channel, {
+                type: 'system',
+                payload: {
+                    message: `${client.nickname} joined #${msg.payload.channel}`,
+                },
+            });
+            break;
+        }
+        case 'leave_channel': {
+            if (!client.nickname) {
+                sendError(client, 'Set your nickname first');
+                return;
+            }
+            const oldChannel = client.currentChannel;
+            if (!oldChannel)
+                break;
+            state_1.state.leaveChannel(client);
+            state_1.state.broadcastToChannel(oldChannel, {
+                type: 'system',
+                payload: { message: `${client.nickname} left #${oldChannel}` },
+            });
+            break;
+        }
+        case 'message': {
+            if (!client.nickname) {
+                sendError(client, 'Set your nickname first');
+                return;
+            }
+            if (!client.currentChannel) {
+                sendError(client, 'Join a channel first');
+                return;
+            }
+            state_1.state
+                .getOrCreateChannel(client.currentChannel)
+                .addMessage({ from: client.nickname, message: msg.payload.text });
+            state_1.state.broadcastToChannel(client.currentChannel, {
+                type: 'message',
+                payload: { from: client.nickname, text: msg.payload.text },
+            }, client.nickname);
+            break;
+        }
+        case 'menu_request':
+            sendMenu(client);
+            break;
+    }
+}
+function parseClientMessage(client, text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        sendError(client, 'Invalid JSON received');
+        return;
+    }
+    const result = schemas_1.ClientMessageSchema.safeParse(parsed);
+    if (!result.success) {
+        sendError(client, (0, utils_1.zodErrorMessage)(result.error));
+        return;
+    }
+    return result.data;
+}
+function sendError(client, message) {
+    client.send({ type: 'error', payload: { message } });
+}
+function sendMenu(client) {
+    if (!client.nickname) {
+        sendError(client, 'Set your nickname first');
+        return;
+    }
+    client.send({
+        type: 'menu',
+        payload: {
+            self: client.nickname,
+            users: state_1.state.listUsers(client.nickname),
+            channels: state_1.state.listChannels(),
+        },
+    });
+}

package/dist/packages/server/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("./server");
+const port = Number(process.env.PORT) || 8080;
+(0, server_1.startServer)(port);

package/dist/packages/server/src/server.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const ws_1 = require("ws");
+const commands_1 = require("./commands");
+const state_1 = require("./state");
+function startServer(port = 8080) {
+    const wss = new ws_1.WebSocketServer({ port });
+    wss.on('connection', (socket) => {
+        const client = new state_1.Client(socket);
+        socket.on('message', data => {
+            (0, commands_1.handleMessage)(client, data.toString());
+        });
+        socket.on('close', () => {
+            const nickname = client.nickname;
+            if (nickname) {
+                state_1.state.broadcastSystem({
+                    type: 'system',
+                    payload: { message: `${nickname} disconnected` },
+                }, nickname);
+            }
+            state_1.state.removeClient(client);
+        });
+    });
+    console.log(`WebSocket server running on ws://localhost:${port}`);
+}

package/dist/packages/server/src/state.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.state = exports.State = exports.Channel = exports.Client = void 0;
+class Client {
+    constructor(socket) {
+        this.nickname = null;
+        this.currentChannel = null;
+        this.socket = socket;
+    }
+    send(data) {
+        this.socket.send(JSON.stringify(data));
+    }
+}
+exports.Client = Client;
+class Channel {
+    constructor(name) {
+        this.name = name;
+        this.clients = new Set();
+        this.history = [];
+        this.MAX_HISTORY = 150;
+    }
+    hasClient(nickname) {
+        return this.clients.has(nickname);
+    }
+    addClient(nickname) {
+        this.clients.add(nickname);
+    }
+    removeClient(nickname) {
+        this.clients.delete(nickname);
+    }
+    listClients() {
+        return [...this.clients];
+    }
+    addMessage(message) {
+        this.history.push(message);
+        if (this.history.length > this.MAX_HISTORY) {
+            this.history.shift();
+        }
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    clearHistory() {
+        this.history.length = 0;
+    }
+}
+exports.Channel = Channel;
+class State {
+    constructor() {
+        this.clients = new Map();
+        this.channels = new Map();
+    }
+    addClient(client) {
+        if (!client.nickname)
+            return;
+        this.clients.set(client.nickname, client);
+    }
+    removeClient(client) {
+        if (!client.nickname)
+            return;
+        if (client.currentChannel) {
+            const channel = this.channels.get(client.currentChannel);
+            if (channel) {
+                channel.removeClient(client.nickname);
+                this.cleanupEmptyChannel(channel);
+            }
+        }
+        this.clients.delete(client.nickname);
+        if (this.clients.size === 0) {
+            this.channels.get('general')?.clearHistory();
+        }
+        this.cleanupAllEmptyChannels();
+    }
+    getClient(nickname) {
+        return this.clients.get(nickname);
+    }
+    listUsers(except) {
+        return [...this.clients.keys()].filter(n => n !== except);
+    }
+    getOrCreateChannel(name) {
+        let channel = this.channels.get(name);
+        if (!channel) {
+            channel = new Channel(name);
+            this.channels.set(name, channel);
+        }
+        return channel;
+    }
+    listChannels() {
+        return [...this.channels.keys()];
+    }
+    joinChannel(client, channelName) {
+        if (!client.nickname)
+            return;
+        if (client.currentChannel) {
+            const oldChannel = this.channels.get(client.currentChannel);
+            oldChannel?.removeClient(client.nickname);
+        }
+        const channel = this.getOrCreateChannel(channelName);
+        channel.addClient(client.nickname);
+        client.send({
+            type: 'channel_history',
+            payload: { channel: channel.name, messages: channel.getHistory() },
+        });
+        client.currentChannel = channelName;
+    }
+    leaveChannel(client) {
+        if (!client.nickname || !client.currentChannel)
+            return;
+        const channel = this.channels.get(client.currentChannel);
+        if (channel) {
+            channel.removeClient(client.nickname);
+            this.cleanupEmptyChannel(channel);
+        }
+        client.currentChannel = null;
+    }
+    broadcastToChannel(channelName, data, exceptNick) {
+        const channel = this.channels.get(channelName);
+        if (!channel)
+            return;
+        for (const nick of channel.listClients()) {
+            if (nick !== exceptNick) {
+                this.clients.get(nick)?.send(data);
+            }
+        }
+    }
+    changeNickname(client, newNick) {
+        const oldNick = client.nickname;
+        if (!oldNick)
+            return;
+        this.clients.delete(oldNick);
+        client.nickname = newNick;
+        this.clients.set(newNick, client);
+        if (client.currentChannel) {
+            const channel = this.channels.get(client.currentChannel);
+            if (channel) {
+                channel.removeClient(oldNick);
+                channel.addClient(newNick);
+            }
+        }
+    }
+    broadcastSystem(data, exceptNick) {
+        for (const [nick, client] of this.clients.entries()) {
+            if (nick !== exceptNick) {
+                client.send(data);
+            }
+        }
+    }
+    cleanupEmptyChannel(channel) {
+        if (channel.listClients().length === 0 &&
+            channel.getHistory().length > 1 &&
+            channel.name !== 'general') {
+            this.channels.delete(channel.name);
+        }
+    }
+    cleanupAllEmptyChannels() {
+        for (const [name, channel] of this.channels) {
+            if (name !== 'general' && channel.listClients().length === 0) {
+                this.channels.delete(name);
+            }
+        }
+    }
+}
+exports.State = State;
+exports.state = new State();
+exports.state.getOrCreateChannel('general');

package/dist/packages/shared/src/schemas.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerMessageSchema = exports.ClientMessageSchema = exports.NicknameSchema = exports.ChannelNameSchema = void 0;
+const zod_1 = require("zod");
+exports.ChannelNameSchema = zod_1.z
+    .string()
+    .min(1)
+    .max(30)
+    .regex(/^[a-z0-9_-]+$/, 'Channel name must be lowercase and contain only letters, numbers, _ or -');
+exports.NicknameSchema = zod_1.z
+    .string()
+    .min(1)
+    .max(20)
+    .regex(/^[a-zA-Z0-9_-]+$/, 'Nickname must contain only letters, numbers, "_" or "-", and no spaces');
+const SetNickMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('set_nick'),
+    payload: zod_1.z.object({
+        nickname: exports.NicknameSchema,
+    }),
+});
+const CheckNickMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('check_nick'),
+    payload: zod_1.z.object({
+        nickname: exports.NicknameSchema,
+    }),
+});
+const JoinMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('join'),
+    payload: zod_1.z.object({
+        channel: exports.ChannelNameSchema,
+    }),
+});
+const ChatMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('message'),
+    payload: zod_1.z.object({
+        text: zod_1.z.string().min(1).max(500),
+    }),
+});
+const MenuRequestSchema = zod_1.z.object({
+    type: zod_1.z.literal('menu_request'),
+});
+const LeaveChannelSchema = zod_1.z.object({
+    type: zod_1.z.literal('leave_channel'),
+});
+exports.ClientMessageSchema = zod_1.z.union([
+    SetNickMessageSchema,
+    CheckNickMessageSchema,
+    JoinMessageSchema,
+    ChatMessageSchema,
+    MenuRequestSchema,
+    LeaveChannelSchema,
+]);
+const ServerChatMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('message'),
+    payload: zod_1.z.object({
+        from: zod_1.z.string(),
+        text: zod_1.z.string().min(1).max(500),
+    }),
+});
+const ServerErrorMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('error'),
+    payload: zod_1.z.object({
+        message: zod_1.z.string(),
+    }),
+});
+const ServerNickCheckSchema = zod_1.z.object({
+    type: zod_1.z.literal('nick_check'),
+    payload: zod_1.z.object({
+        nickname: zod_1.z.string(),
+        available: zod_1.z.boolean(),
+    }),
+});
+const ServerWelcomeMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('welcome'),
+    payload: zod_1.z.object({
+        nickname: zod_1.z.string(),
+        users: zod_1.z.array(zod_1.z.string()),
+        channels: zod_1.z.array(zod_1.z.string()),
+    }),
+});
+const ServerUserJoinedSchema = zod_1.z.object({
+    type: zod_1.z.literal('user_joined'),
+    payload: zod_1.z.object({
+        nickname: zod_1.z.string(),
+        channel: zod_1.z.string(),
+    }),
+});
+const ServerUserLeftSchema = zod_1.z.object({
+    type: zod_1.z.literal('user_left'),
+    payload: zod_1.z.object({
+        nickname: zod_1.z.string(),
+    }),
+});
+const ServerNickChangedSchema = zod_1.z.object({
+    type: zod_1.z.literal('nick_changed'),
+    payload: zod_1.z.object({
+        oldNick: zod_1.z.string(),
+        newNick: zod_1.z.string(),
+    }),
+});
+const ServerMenuSchema = zod_1.z.object({
+    type: zod_1.z.literal('menu'),
+    payload: zod_1.z.object({
+        self: zod_1.z.string(),
+        users: zod_1.z.array(zod_1.z.string()),
+        channels: zod_1.z.array(zod_1.z.string()),
+    }),
+});
+const ServerChannelHistorySchema = zod_1.z.object({
+    type: zod_1.z.literal('channel_history'),
+    payload: zod_1.z.object({
+        channel: zod_1.z.string(),
+        messages: zod_1.z.array(zod_1.z.object({
+            from: zod_1.z.string(),
+            message: zod_1.z.string(),
+        })),
+    }),
+});
+const ServerSystemMessageSchema = zod_1.z.object({
+    type: zod_1.z.literal('system'),
+    payload: zod_1.z.object({
+        message: zod_1.z.string(),
+    }),
+});
+exports.ServerMessageSchema = zod_1.z.union([
+    ServerChatMessageSchema,
+    ServerErrorMessageSchema,
+    ServerWelcomeMessageSchema,
+    ServerUserJoinedSchema,
+    ServerUserLeftSchema,
+    ServerNickChangedSchema,
+    ServerNickCheckSchema,
+    ServerMenuSchema,
+    ServerChannelHistorySchema,
+    ServerSystemMessageSchema,
+]);

package/dist/packages/shared/src/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodErrorMessage = zodErrorMessage;
+function zodErrorMessage(err) {
+    if (!err.issues.length) {
+        return 'Invalid message format';
+    }
+    return err.issues.map(i => i.message).join('\n');
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@bruggmann._/ccli",
+  "private": false,
+  "version": "1.0.0",
+  "description": "Chat Command Line Interface using WebSockets (TypeScript)",
+  "bin": {
+    "ccli": "dist/packages/client/src/index.js"
+  },
+  "main": "dist/packages/client/src/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsc --project tsconfig.build.json && tsc-alias --project tsconfig.build.json",
+    "start": "node dist/packages/server/src/index.js",
+    "server": "nodemon --watch packages/server --exec \"ts-node -r tsconfig-paths/register --project tsconfig.json\" packages/server/src/index.ts",
+    "client": "ts-node -r tsconfig-paths/register --project packages/client/tsconfig.json packages/client/src/index.ts"
+  },
+  "keywords": [
+    "cli",
+    "chat",
+    "websocket",
+    "typescript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "dotenv": "^17.2.4",
+    "undici-types": "^7.19.1",
+    "ws": "^8.19.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "@types/ws": "^8.18.1",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.16",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3"
+  }
+}