hacker-lobby 1.0.0

package/index.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+import readline from 'readline';
+import { 
+  clearScreen, 
+  drawBanner, 
+  formatMessage, 
+  formatSystem, 
+  formatError, 
+  COLORS,
+  setScrollRegion,
+  resetScrollRegion,
+  moveCursor,
+  saveCursor,
+  restoreCursor,
+  clearCurrentLine
+} from './src/ui.js';
+import { setAlias, getAlias } from './src/config.js';
+import { connectToStream, sendMessage } from './src/api.js';
+
+let abortController = null;
+
+// Setup readline interface
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const messages = [];
+let chatActive = false;
+let muteNewline = false;
+
+// Override stdout.write to intercept the readline newline on enter keypress.
+// This prevents the entire terminal window from scrolling up when the user submits a message.
+const originalWrite = process.stdout.write.bind(process.stdout);
+process.stdout.write = (chunk, encoding, callback) => {
+  const data = chunk.toString();
+  if (muteNewline && (data === '\n' || data === '\r\n' || data === '\r')) {
+    return true;
+  }
+  return originalWrite(chunk, encoding, callback);
+};
+
+// Monitor stdin keypresses to catch Enter and mute the corresponding newline.
+process.stdin.on('keypress', (char, key) => {
+  if (key && (key.name === 'return' || key.name === 'enter')) {
+    muteNewline = true;
+  }
+});
+
+function promptAlias() {
+  clearScreen();
+  drawBanner();
+  
+  process.stdout.write(`${COLORS.YELLOW}${COLORS.BOLD}Choose an alias: ${COLORS.RESET}`);
+  
+  rl.question('', (input) => {
+    const alias = input.trim();
+    if (!alias) {
+      process.stdout.write('\n' + formatError('Alias cannot be empty. Please try again.') + '\n');
+      setTimeout(promptAlias, 1500);
+      return;
+    }
+    
+    setAlias(alias);
+    initChat();
+  });
+}
+
+function initChat() {
+  chatActive = true;
+  
+  // Set up initial layout and scroll regions
+  drawLayout();
+  
+  // Add welcome system messages
+  addSystemMessage(`Welcome @${getAlias()} to the HACKER LOBBY!`);
+  addSystemMessage(`Type your message and press Enter. Type "/exit" to leave.`);
+  
+  // Set up prompt
+  const promptStr = `${COLORS.CYAN}${COLORS.BOLD}[${getAlias()}]: ${COLORS.RESET}`;
+  rl.setPrompt(promptStr);
+  
+  // Connect to backend Server-Sent Events stream
+  abortController = new AbortController();
+  connectToStream((message) => {
+    addMessage(message.username, message.content);
+  }, abortController.signal).catch((err) => {
+    addSystemMessage(`Stream disconnected: ${err.message}`);
+  });
+  
+  rl.on('line', (line) => {
+    // Disable newline muting once readline has finished processing the line
+    muteNewline = false;
+    
+    const text = line.trim();
+    if (text) {
+      if (text === '/exit' || text === '/quit') {
+        cleanupAndExit();
+      }
+      
+      // Post the message to the Edge server
+      sendMessage(getAlias(), text).catch((err) => {
+        addSystemMessage(`Failed to send message: ${err.message}`);
+      });
+    }
+    
+    // Redraw prompt at the bottom
+    const rows = process.stdout.rows || 24;
+    moveCursor(rows, 1);
+    clearCurrentLine();
+    rl.prompt(true);
+  });
+
+  // Handle window resizing dynamically
+  process.stdout.on('resize', () => {
+    if (chatActive) {
+      drawLayout();
+    }
+  });
+  
+  // Initial prompt display
+  rl.prompt(true);
+}
+
+function drawLayout() {
+  const rows = process.stdout.rows || 24;
+  const cols = process.stdout.columns || 80;
+  
+  // Clear screen completely
+  clearScreen();
+  
+  // 1. Draw static header banner if screen has enough space
+  const hasBanner = rows > 16;
+  let topMargin = 1;
+  
+  if (hasBanner) {
+    drawBanner();
+    topMargin = 11; // Banner + borders take 10 rows
+  }
+  
+  const bottomMargin = rows - 2;
+  
+  // 2. Draw static divider line just above the input prompt
+  moveCursor(rows - 1, 1);
+  process.stdout.write(COLORS.GRAY + '─'.repeat(cols) + COLORS.RESET);
+  
+  // 3. Set the scrolling region for messages
+  setScrollRegion(topMargin, bottomMargin);
+  
+  // 4. Fill the scrolling region with message history
+  const maxMessages = bottomMargin - topMargin + 1;
+  const history = messages.slice(-maxMessages);
+  
+  for (let i = 0; i < history.length; i++) {
+    moveCursor(topMargin + i, 1);
+    process.stdout.write(history[i]);
+  }
+  
+  // Clear remaining lines in scroll region if history is short
+  for (let i = history.length; i < maxMessages; i++) {
+    moveCursor(topMargin + i, 1);
+    clearCurrentLine();
+  }
+  
+  // 5. Position cursor on the bottom row for typing
+  moveCursor(rows, 1);
+  clearCurrentLine();
+  
+  // 6. Display prompt
+  const promptStr = `${COLORS.CYAN}${COLORS.BOLD}[${getAlias()}]: ${COLORS.RESET}`;
+  rl.setPrompt(promptStr);
+  rl.prompt(true);
+}
+
+function addMessage(sender, text) {
+  const formatted = formatMessage(sender, text);
+  messages.push(formatted);
+  
+  const rows = process.stdout.rows || 24;
+  const bottomMargin = rows - 2;
+  
+  // Move to bottom of scroll area
+  moveCursor(bottomMargin, 1);
+  process.stdout.write(formatted + '\n');
+  
+  // Restore cursor to prompt line
+  const promptLength = getAlias().length + 4;
+  const col = promptLength + (rl.cursor || 0) + 1;
+  moveCursor(rows, col);
+}
+
+function addSystemMessage(text) {
+  const formatted = formatSystem(text);
+  messages.push(formatted);
+  
+  const rows = process.stdout.rows || 24;
+  const bottomMargin = rows - 2;
+  
+  // Move to bottom of scroll area
+  moveCursor(bottomMargin, 1);
+  process.stdout.write(formatted + '\n');
+  
+  // Restore cursor to prompt line
+  const promptLength = getAlias().length + 4;
+  const col = promptLength + (rl.cursor || 0) + 1;
+  moveCursor(rows, col);
+}
+
+function cleanupAndExit() {
+  if (abortController) {
+    abortController.abort();
+  }
+  resetScrollRegion();
+  clearScreen();
+  console.log(formatSystem('Goodbye!'));
+  process.exit(0);
+}
+
+// Start the entry point sequence
+promptAlias();

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "hacker-lobby",
+  "version": "1.0.0",
+  "description": "Multiplayer terminal chat application",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "hacker-lobby": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "files": [
+    "index.js",
+    "src"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/api.js

@@ -0,0 +1,76 @@
+const API_URL = process.env.API_URL || 'https://hacker-lobby-backend.spidozx.workers.dev';
+
+/**
+ * Connects to the SSE stream at /listen and parses incoming messages in real-time.
+ * @param {Function} onMessageCallback - Invoked with parsed message JSON payload.
+ * @param {AbortSignal} [signal] - Optional signal to abort/disconnect the connection.
+ */
+export async function connectToStream(onMessageCallback, signal) {
+  const url = `${API_URL}/listen`;
+
+  try {
+    const response = await fetch(url, { signal });
+
+    if (!response.ok) {
+      throw new Error(`Failed to connect to stream: ${response.statusText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('ReadableStream not supported or empty body');
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    for await (const chunk of response.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split('\n');
+
+      // The last line may be incomplete, hold it in the buffer
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('data: ')) {
+          try {
+            const data = JSON.parse(trimmed.slice(6));
+            onMessageCallback(data);
+          } catch (e) {
+            // Ignore malformed JSON or SSE control lines
+          }
+        }
+      }
+    }
+  } catch (err) {
+    // Suppress error if aborted intentionally
+    if (err.name === 'AbortError' || (signal && signal.aborted)) {
+      return;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Sends a message to the edge server POST /say endpoint.
+ * @param {string} user - Username of the sender.
+ * @param {string} text - Message text content.
+ * @returns {Promise<Object>} Response JSON.
+ */
+export async function sendMessage(user, text) {
+  const url = `${API_URL}/say`;
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ user, text }),
+  });
+
+  if (!response.ok) {
+    const errData = await response.json().catch(() => ({}));
+    throw new Error(errData.error || `HTTP error! Status: ${response.status}`);
+  }
+
+  return response.json();
+}

package/src/config.js

@@ -0,0 +1,19 @@
+export const state = {
+  alias: '',
+};
+
+/**
+ * Set the user's chosen alias
+ * @param {string} alias 
+ */
+export function setAlias(alias) {
+  state.alias = alias.trim();
+}
+
+/**
+ * Get the user's current alias
+ * @returns {string}
+ */
+export function getAlias() {
+  return state.alias;
+}

package/src/ui.js

@@ -0,0 +1,122 @@
+export const COLORS = {
+  RESET: '\x1b[0m',
+  BOLD: '\x1b[1m',
+  DIM: '\x1b[2m',
+  ITALIC: '\x1b[3m',
+  UNDERLINE: '\x1b[4m',
+  
+  // Foreground Colors
+  RED: '\x1b[31m',
+  GREEN: '\x1b[32m',
+  YELLOW: '\x1b[33m',
+  BLUE: '\x1b[34m',
+  MAGENTA: '\x1b[35m',
+  CYAN: '\x1b[36m',
+  WHITE: '\x1b[37m',
+  GRAY: '\x1b[90m',
+  
+  // Custom theme colors
+  NEON_GREEN: '\x1b[38;5;82m',
+  NEON_CYAN: '\x1b[38;5;87m',
+  DARK_GRAY: '\x1b[38;5;240m',
+};
+
+/**
+ * Clear the entire terminal screen and scrollback buffer,
+ * then place cursor at top-left.
+ */
+export function clearScreen() {
+  process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+}
+
+/**
+ * Render the high-impact hacker lobby ASCII banner
+ */
+export function drawBanner() {
+  const banner = `
+${COLORS.CYAN} ██╗  ██╗ █████╗  ██████╗██╗  ██╗███████╗██████╗     ██╗      ██████╗ ██████╗ ██████╗ ██╗   ██╗
+ ██║  ██║██╔══██╗██╔════╝██║ ██╔╝██╔════╝██╔══██╗    ██║     ██╔═══██╗██╔══██╗██╔══██╗╚██╗ ██╔╝
+ ███████║███████║██║     █████╔╝ █████╗  ██████╔╝    ██║     ██║   ██║██████╔╝██████╔╝ ╚████╔╝ 
+ ██╔══██║██╔══██║██║     ██╔═██╗ ██╔══╝  ██╔══██╗    ██║     ██║   ██║██╔══██╗██╔══██╗  ╚██╔╝  
+ ██║  ██║██║  ██║╚██████╗██║  ██╗███████╗██║  ██║    ███████╗╚██████╔╝██████╔╝██████╔╝   ██║   
+ ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝    ╚══════╝ ╚══════╝╚══════╝╚══════╝    ╚═╝${COLORS.RESET}
+`;
+  process.stdout.write(banner);
+  process.stdout.write(`\n${COLORS.GRAY}===========================================================================================${COLORS.RESET}\n`);
+  process.stdout.write(`${COLORS.NEON_GREEN}${COLORS.BOLD}  [SECURE MULTIPLAYER CHAT LOBBY] — TYPE /exit TO QUIT${COLORS.RESET}\n`);
+  process.stdout.write(`${COLORS.GRAY}===========================================================================================${COLORS.RESET}\n\n`);
+}
+
+/**
+ * Formats user chat message
+ * @param {string} sender 
+ * @param {string} text 
+ * @returns {string}
+ */
+export function formatMessage(sender, text) {
+  return `${COLORS.CYAN}${COLORS.BOLD}${sender}${COLORS.RESET}: ${text}`;
+}
+
+/**
+ * Formats a system status message
+ * @param {string} text 
+ * @returns {string}
+ */
+export function formatSystem(text) {
+  return `${COLORS.GREEN}${COLORS.BOLD}[SYSTEM]${COLORS.RESET} ${COLORS.NEON_GREEN}${text}${COLORS.RESET}`;
+}
+
+/**
+ * Formats an error notification
+ * @param {string} text 
+ * @returns {string}
+ */
+export function formatError(text) {
+  return `${COLORS.RED}${COLORS.BOLD}[ERROR]${COLORS.RESET} ${COLORS.RED}${text}${COLORS.RESET}`;
+}
+
+/**
+ * Set terminal scrolling region (rows 1-indexed)
+ * @param {number} top 
+ * @param {number} bottom 
+ */
+export function setScrollRegion(top, bottom) {
+  process.stdout.write(`\x1b[${top};${bottom}r`);
+}
+
+/**
+ * Reset terminal scrolling region to full window
+ */
+export function resetScrollRegion() {
+  process.stdout.write('\x1b[r');
+}
+
+/**
+ * Move cursor to a specific row and column
+ * @param {number} row 
+ * @param {number} col 
+ */
+export function moveCursor(row, col) {
+  process.stdout.write(`\x1b[${row};${col}H`);
+}
+
+/**
+ * Save current cursor position
+ */
+export function saveCursor() {
+  process.stdout.write('\x1b[s');
+}
+
+/**
+ * Restore previously saved cursor position
+ */
+export function restoreCursor() {
+  process.stdout.write('\x1b[u');
+}
+
+/**
+ * Clear the current cursor line
+ */
+export function clearCurrentLine() {
+  process.stdout.write('\x1b[2K');
+}

package/src/worker.js

@@ -0,0 +1,188 @@
+// Active SSE connection writers
+const activeConnections = new Set();
+
+// Regex to match ANSI escape sequences (control codes, color formatting, etc.)
+const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+/**
+ * Sanitizes input strings by stripping out all ANSI escape sequences to prevent terminal XSS.
+ * @param {string} str
+ * @returns {string}
+ */
+function sanitizeAnsi(str) {
+  if (typeof str !== 'string') return '';
+  return str.replace(ansiRegex, '');
+}
+
+export default {
+  /**
+   * Fetch handler for Cloudflare Worker.
+   * @param {Request} request
+   * @param {Object} env
+   * @param {Object} ctx
+   * @returns {Promise<Response>}
+   */
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+
+    // Helper for structured JSON responses
+    const jsonResponse = (data, status = 200) => {
+      return new Response(JSON.stringify(data), {
+        status,
+        headers: {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers': '*',
+        },
+      });
+    };
+
+    // Handle OPTIONS request for CORS preflight
+    if (request.method === 'OPTIONS') {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers': '*',
+        },
+      });
+    }
+
+    // Routing for GET /listen
+    if (url.pathname === '/listen') {
+      if (request.method !== 'GET') {
+        return jsonResponse({ error: 'Method Not Allowed' }, 405);
+      }
+
+      const { readable, writable } = new TransformStream();
+      const writer = writable.getWriter();
+
+      // Add writer to active connections tracking
+      activeConnections.add(writer);
+
+      // Handle connection disconnect to prevent memory leaks
+      request.signal.addEventListener('abort', () => {
+        activeConnections.delete(writer);
+        try {
+          writer.close();
+        } catch (_) {}
+      });
+
+      // Keep-alive or immediate connection handshake
+      const encoder = new TextEncoder();
+      writer.write(encoder.encode(': ok\n\n')).catch(() => {});
+
+      return new Response(readable, {
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': '*',
+          'Access-Control-Allow-Methods': 'GET, OPTIONS',
+        },
+      });
+    }
+
+    // Routing for POST /say
+    if (url.pathname === '/say') {
+      if (request.method !== 'POST') {
+        return jsonResponse({ error: 'Method Not Allowed' }, 405);
+      }
+
+      try {
+        const body = await request.json();
+        const { user, text } = body || {};
+
+        // Validation: parameters must exist, be strings, and not be empty
+        if (!user || typeof user !== 'string' || !user.trim()) {
+          return jsonResponse({ error: 'Missing or invalid "user" parameter' }, 400);
+        }
+
+        if (!text || typeof text !== 'string' || !text.trim()) {
+          return jsonResponse({ error: 'Missing or invalid "text" parameter' }, 400);
+        }
+
+        // Sanitize username and content of ANSI escape sequences to prevent terminal XSS
+        const sanitizedUser = sanitizeAnsi(user);
+        const sanitizedText = sanitizeAnsi(text);
+
+        // Ensure database binding exists
+        if (!env.DB) {
+          return jsonResponse({ error: 'Database binding "DB" is not configured' }, 500);
+        }
+
+        // Insert into D1 messages table safely using parameterized bindings
+        await env.DB.prepare(
+          'INSERT INTO messages (username, content) VALUES (?, ?)'
+        )
+          .bind(sanitizedUser, sanitizedText)
+          .run();
+
+        // Broadcast the message payload to all active SSE subscribers
+        const encoder = new TextEncoder();
+        const payload = JSON.stringify({
+          username: sanitizedUser,
+          content: sanitizedText,
+          created_at: new Date().toISOString(),
+        });
+        const messageChunk = encoder.encode(`data: ${payload}\n\n`);
+
+        const broadcastPromises = Array.from(activeConnections).map(async (w) => {
+          try {
+            await w.write(messageChunk);
+          } catch (_) {
+            activeConnections.delete(w);
+            try {
+              w.close();
+            } catch (__) {}
+          }
+        });
+        
+        // Wait for all active broadcasts
+        await Promise.all(broadcastPromises);
+
+        return jsonResponse({
+          success: true,
+          message: 'Message sent successfully',
+          data: {
+            username: sanitizedUser,
+            content: sanitizedText,
+          },
+        }, 201);
+
+      } catch (err) {
+        return jsonResponse({ error: `Bad Request: ${err.message}` }, 400);
+      }
+    }
+
+    // Default route
+    return jsonResponse({ error: 'Not Found' }, 404);
+  },
+
+  /**
+   * Cron Trigger handler for database cleanup.
+   * Runs at the top of every hour.
+   * Deletes messages older than 6 hours.
+   * @param {Object} event
+   * @param {Object} env
+   * @param {Object} ctx
+   */
+  async scheduled(event, env, ctx) {
+    if (!env.DB) {
+      console.error('[Cron Trigger] Database binding "DB" is not configured');
+      return;
+    }
+
+    try {
+      const result = await env.DB.prepare(
+        "DELETE FROM messages WHERE created_at < datetime('now', '-6 hours')"
+      ).run();
+      console.log(`[Cron Trigger] Cleanup complete. Deleted rows: ${result.meta.changes || 0}`);
+    } catch (err) {
+      console.error('[Cron Trigger] Failed to delete old messages:', err);
+    }
+  },
+};