@miraj181/ipingyou 1.0.2 → 2.0.0

package/README.md

@@ -1,62 +1,53 @@
 # 🔗 iPingYou — SecureLink CLI
 
-Secure peer-to-peer remote access via SSH & Cloudflare Tunnels. A Node.js CLI tool that lets two machines establish an encrypted SSH connection through Cloudflare's network, coordinated by a lightweight broker.
+Secure peer-to-peer remote access via SSH & Cloudflare Tunnels. A zero-configuration Node.js CLI tool that lets two machines establish an encrypted SSH connection through Cloudflare's network, instantly.
 
 ## Architecture
 
 ```
- Host Machine                  Broker (Express.js)              Client Machine
-┌──────────────┐   POST       ┌──────────────────┐   GET       ┌──────────────┐
-│ cloudflared  │──/register──▶│  In-Memory Map   │◀─/resolve──│  ipingyou    │
-│ tunnel :22   │   {uid,url}  │  AES-256-CBC     │   /:uid     │  connect     │
-│              │              │  1hr TTL expiry   │             │              │
-│  SSH daemon  │◀─────────────│──────────────────│─────────────│  SSH via     │
-│              │  cloudflared │                   │ ProxyCmd    │  ProxyCmd    │
-└──────────────┘  TCP proxy   └──────────────────┘             └──────────────┘
+ Host Machine                                                     Client Machine
+┌──────────────┐   POST                          GET       ┌──────────────┐
+│ cloudflared  │──/register──▶[Broker Server]◀─/resolve──│   ipingyou   │
+│ tunnel :22   │   {uid,url}  (Render Hosted)    /:uid     │   connect    │
+│              │              AES-256-CBC                  │              │
+│  SSH daemon  │◀─────────────               ─────────────│  SSH via     │
+│              │  cloudflared                 ProxyCmd    │  ProxyCmd    │
+└──────────────┘  TCP proxy                                └──────────────┘
 ```
 
 ### Flow
-1. **Host** starts `ipingyou host` → generates an 8-char UID, spins up `cloudflared` tunnel, registers with broker
-2. **Host** shares UID with the client (verbally, chat, etc.)
-3. **Client** runs `ipingyou connect` → enters UID, broker resolves it to tunnel URL → SSH connects via cloudflared proxy
-4. On `Ctrl+C`, all spawned processes are killed via `tree-kill` and the UID is revoked from the broker
+1. **Host** starts `ipingyou host` → generates an 8-char UID, spins up `cloudflared` tunnel, and registers with the broker.
+2. **Host** shares the UID with the client.
+3. **Client** runs `ipingyou connect` → enters UID, broker resolves it to tunnel URL → SSH connects via cloudflared proxy.
+4. On `Ctrl+C`, all spawned processes are killed via `tree-kill` and the UID is automatically revoked from the broker.
 
-## Quick Start
+## Usage
 
-### 1. Start the Broker (self-hosted or Render)
+You do not need to clone the repository or configure any `.env` files. `iPingYou` is purely published on npm and handles the backend API automatically!
+
+### The "On-the-Fly" Way (Recommended)
+Run it anywhere using `npx` (make sure you aren't inside the project source code folder):
 
 ```bash
-cd ipingyou
-cp .env.example .env
-npm install
-npm run broker
-# Broker: http://localhost:4000
-```
+# Start the interactive wizard
+npx @miraj181/ipingyou
 
-### 2. Host Mode (Machine being accessed)
+# Or instantly start as a Host
+npx @miraj181/ipingyou host
 
-```bash
-npx ipingyou host
-# or interactively:
-npx ipingyou
+# Or instantly connect as a Client
+npx @miraj181/ipingyou connect
 ```
 
-### 3. Client Mode (Machine accessing)
+### Global Install
+If you use the tool frequently, install it globally:
 
 ```bash
-npx ipingyou connect
-# or interactively:
-npx ipingyou
-```
-
-## CLI Commands
+npm install -g @miraj181/ipingyou
 
-```
-ipingyou                    Interactive mode (prompts for host/client)
-ipingyou host               Start as host — allow remote access
-ipingyou connect            Start as client — access a remote machine
-ipingyou broker             Start the central broker server
-ipingyou broker -p 5000     Start broker on custom port
+# Run as native commands:
+ipingyou
+securelink
 ```
 
 ## Prerequisites
@@ -67,66 +58,15 @@ ipingyou broker -p 5000     Start broker on custom port
 | `ssh` | ✅ | Ships with macOS/Linux; `winget install Microsoft.OpenSSH.Client` on Windows |
 | `cloudflared` | ✅ | `brew install cloudflared` / [download](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/) |
 
-The CLI auto-detects your OS and will attempt to install missing dependencies on Linux (apt/pacman) and guide you on macOS/Windows.
-
-## Project Structure
-
-```
-ipingyou/
-├── src/
-│   ├── cli.js              ← Main CLI entry (npx-ready, shebang)
-│   ├── server.js           ← Central Broker (Express.js)
-│   ├── lib/
-│   │   ├── cleanup.js      ← Graceful shutdown + tree-kill
-│   │   ├── crypto.js       ← AES-256-CBC encrypt/decrypt
-│   │   ├── platform.js     ← OS detection + dependency check
-│   │   └── uid.js          ← Random 8-char UID generator (nanoid)
-│   └── modes/
-│       ├── host.js         ← Host mode logic
-│       └── client.js       ← Client mode logic
-├── .env.example
-├── .gitignore
-├── package.json
-├── render.yaml             ← One-click Render deploy
-└── README.md
-```
+*The CLI auto-detects your OS and will attempt to guide you on how to install missing dependencies!*
 
 ## Security
 
-- **AES-256-CBC** — Tunnel URLs are encrypted at rest in the broker's memory
-- **Random UIDs** — 8-char nanoid, not hardware-based; session dies = door locked forever
-- **1-hour TTL** — Broker auto-expires entries; no stale data
-- **Auto-revoke** — On `Ctrl+C`, UID is deleted from broker before exit
-- **tree-kill** — All child processes (cloudflared, SSH) are recursively killed on shutdown
-- **No persistence** — Broker uses in-memory Map only; server restart = clean slate
-
-## Deploy Broker to Render (Free)
-
-1. Push this repo to GitHub
-2. Go to [render.com/new](https://render.com/new)
-3. Click **"New Web Service"** → connect your repo
-4. Render auto-detects `render.yaml` → click **Deploy**
-5. Set `SECRET_KEY` in Render Dashboard → Environment
-6. Set `BROKER_URL` in your local `.env` to your Render URL
-
-## Environment Variables
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `SECRET_KEY` | Dev key | AES-256 hex key (64 chars) |
-| `BROKER_URL` | `http://localhost:4000` | Broker endpoint for CLI |
-| `BROKER_PORT` | `4000` | Port for broker server |
-
-## Differences from remote-penitrator
-
-| Aspect | remote-penitrator | iPingYou |
-|--------|-------------------|----------|
-| Interface | Shell scripts + web dashboard | Interactive Node.js CLI |
-| Direction | One-way (runner → C2) | Peer-to-peer (host ↔ client) |
-| UID System | Hardcoded PC IDs | Random per-session UIDs |
-| Process Mgmt | Manual | tree-kill auto-cleanup |
-| Install | Copy scripts | `npx ipingyou` |
-| Modes | Reporter only | Host + Client + Broker |
+- **Zero-Knowledge Architecture** — The broker never sees the plaintext Cloudflare URL. It is strictly used as an encrypted key-value store.
+- **AES-256-CBC** — Tunnel URLs are encrypted locally before being transmitted to the broker.
+- **Random UIDs** — 8-char nanoid, not hardware-based. When the session dies, the door is locked forever.
+- **Auto-revoke** — On `Ctrl+C`, UID is immediately deleted from the broker before exit.
+- **No Persistence** — Broker uses an in-memory Map only with strict 1-hour TTLs.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraj181/ipingyou",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "SecureLink-CLI — Secure peer-to-peer remote access via SSH & Cloudflare Tunnels",
   "main": "src/cli.js",
   "bin": {
@@ -45,10 +45,15 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "execa": "^9.5.2",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.5.2",
+    "helmet": "^8.1.0",
     "inquirer": "^12.3.2",
     "nanoid": "^5.0.9",
+    "open": "^11.0.0",
     "ora": "^8.1.1",
-    "tree-kill": "^1.2.2"
+    "tree-kill": "^1.2.2",
+    "ws": "^8.20.1"
   },
   "devDependencies": {
     "nodemon": "^3.1.4"
@@ -57,4 +62,4 @@
     "node": ">=18.0.0"
   },
   "type": "module"
-}
+}

package/src/cli.js

@@ -23,9 +23,14 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 
 import { detectOS, checkDependencies } from './lib/platform.js';
-import { installShutdownHandlers } from './lib/cleanup.js';
+import { installShutdownHandlers, executePanicMode } from './lib/cleanup.js';
 import { startHostMode } from './modes/host.js';
 import { startClientMode } from './modes/client.js';
+import { execa } from 'execa';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 // ─── ASCII Banner ────────────────────────────────────────────
 function showBanner() {
@@ -67,10 +72,20 @@ function showRichHelp() {
   console.log(`    • The Broker never sees your plaintext URL, only ciphertext.`);
   console.log('');
 
+  console.log(chalk.bold.white('  🔥 Advanced Features:'));
+  console.log(`    • ${chalk.green('Terminal Mirroring')}   : Host can spectate connected SSH clients in real-time.`);
+  console.log(`    • ${chalk.green('Reverse Forwarding')} : Clients can expose their local localhost ports back to the Host.`);
+  console.log(`    • ${chalk.green('E2E Chat Room')}      : Real-time Web Crypto AES-GCM secure chat UI for Host & Clients.`);
+  console.log(`    • ${chalk.green('Daemonization')}      : Run Host mode as a background service via PM2.`);
+  console.log(`    • ${chalk.green('Panic Kill-Switch')}  : Instantly purge all processes, configurations, and traces.`);
+  console.log('');
+
   console.log(chalk.bold.white('  💡 Examples:'));
-  console.log(`    $ npx ipingyou          ${chalk.dim('# Interactive wizard (Recommended)')}`);
-  console.log(`    $ npx ipingyou host     ${chalk.dim('# Quick start as Host')}`);
-  console.log(`    $ npx ipingyou connect  ${chalk.dim('# Quick start as Client')}`);
+  console.log(`    $ npx ipingyou                  ${chalk.dim('# Interactive wizard (Recommended)')}`);
+  console.log(`    $ npx ipingyou host             ${chalk.dim('# Quick start as Host')}`);
+  console.log(`    $ npx ipingyou connect          ${chalk.dim('# Quick start as Client')}`);
+  console.log(`    $ npx ipingyou panic            ${chalk.dim('# Self-destruct and wipe memory/traces')}`);
+  console.log(`    $ npx ipingyou service install  ${chalk.dim('# Install Host mode as a background daemon')}`);
   console.log('');
 }
 
@@ -91,6 +106,16 @@ function fatal(context, err) {
   process.exit(1);
 }
 
+// ─── Process-Level Error Catching ────────────────────────────
+process.on('uncaughtException', (err) => {
+  fatal('uncaughtException', err);
+});
+
+process.on('unhandledRejection', (reason) => {
+  const err = reason instanceof Error ? reason : new Error(String(reason));
+  fatal('unhandledRejection', err);
+});
+
 // ─── Interactive Mode Selection ──────────────────────────────
 async function interactiveMode() {
   showBanner();
@@ -158,6 +183,7 @@ program
   .name('ipingyou')
   .description('SecureLink-CLI — Secure P2P remote access via SSH & Cloudflare Tunnels')
   .version('1.0.0')
+  .option('-b, --broker <url>', 'Override the central broker URL')
   .addHelpText('beforeAll', () => {
     showBanner();
     showRichHelp();
@@ -169,6 +195,9 @@ program
   .description('Start host mode — allow remote access to this machine')
   .action(async () => {
     try {
+      const opts = program.opts();
+      if (opts.broker) process.env.BROKER_URL = opts.broker;
+
       showBanner();
       showSystemInfo();
       installShutdownHandlers();
@@ -185,6 +214,9 @@ program
   .option('-u, --uid <uid>', 'The remote host UID')
   .action(async () => {
     try {
+      const opts = program.opts();
+      if (opts.broker) process.env.BROKER_URL = opts.broker;
+
       showBanner();
       showSystemInfo();
       installShutdownHandlers();
@@ -195,9 +227,57 @@ program
     }
   });
 
+program
+  .command('panic')
+  .description('🚨 Self-destruct mode: wipe all configs, kill tunnels, and remove traces')
+  .action(async () => {
+    try {
+      showBanner();
+      await executePanicMode();
+    } catch (err) {
+      fatal('panic', err);
+    }
+  });
+
+program
+  .command('service <action>')
+  .description('👻 Manage background daemon (actions: install, stop, status)')
+  .action(async (action) => {
+    try {
+      showBanner();
+      console.log(chalk.bold.cyan('  👻 Background Service Manager'));
+      console.log(chalk.dim('  ──────────────────────────────────────'));
+      
+      const { execaCommand } = await import('execa');
+      
+      if (action === 'install') {
+        console.log(chalk.dim('  Installing PM2 globally and starting host...'));
+        await execaCommand('npm install -g pm2', { stdio: 'inherit' });
+        await execaCommand('pm2 start ipingyou --name "ipingyou-host" -- host', { stdio: 'inherit' });
+        await execaCommand('pm2 save', { stdio: 'inherit' });
+        await execaCommand('pm2 startup', { stdio: 'inherit' });
+        console.log(chalk.green('\n  ✅ Service installed and running in the background.'));
+      } else if (action === 'stop') {
+        await execaCommand('pm2 stop ipingyou-host', { stdio: 'inherit' });
+        await execaCommand('pm2 delete ipingyou-host', { stdio: 'inherit' });
+        await execaCommand('pm2 save', { stdio: 'inherit' });
+        console.log(chalk.green('\n  ✅ Service stopped and removed.'));
+      } else if (action === 'status') {
+        await execaCommand('pm2 status ipingyou-host', { stdio: 'inherit' });
+      } else {
+        console.log(chalk.red(`  ❌ Unknown action: ${action}. Use install, stop, or status.`));
+      }
+    } catch (err) {
+      fatal('service', err);
+    }
+  });
+
 // ─── Default: interactive mode ──────────────────────────────
 program.action(async () => {
   try {
+    const opts = program.opts();
+    if (opts.broker) process.env.BROKER_URL = opts.broker;
+
     installShutdownHandlers();
     await interactiveMode();
   } catch (err) {

package/src/lib/chat.js

@@ -0,0 +1,333 @@
+import http from 'node:http';
+import { WebSocketServer } from 'ws';
+import open from 'open';
+import chalk from 'chalk';
+
+const HTML_CONTENT = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>iPingYou — Secure Chat Room</title>
+  <style>
+    :root {
+      --bg: #0f172a;
+      --bg-panel: #1e293b;
+      --text: #f8fafc;
+      --primary: #38bdf8;
+      --accent: #818cf8;
+      --danger: #ef4444;
+      --border: #334155;
+    }
+    body {
+      margin: 0; padding: 0; font-family: 'Inter', system-ui, sans-serif;
+      background: var(--bg); color: var(--text); height: 100vh; display: flex; flex-direction: column;
+    }
+    header {
+      background: var(--bg-panel); padding: 1rem 2rem; border-bottom: 1px solid var(--border);
+      display: flex; justify-content: space-between; align-items: center; box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+    }
+    h1 { margin: 0; font-size: 1.25rem; font-weight: 600; display: flex; align-items: center; gap: 0.5rem; }
+    .badge { background: var(--primary); color: #000; padding: 0.2rem 0.5rem; border-radius: 999px; font-size: 0.8rem; font-weight: bold; }
+    .leave-btn {
+      background: var(--danger); color: white; border: none; padding: 0.5rem 1rem; border-radius: 0.5rem;
+      font-weight: bold; cursor: pointer; transition: opacity 0.2s;
+    }
+    .leave-btn:hover { opacity: 0.8; }
+    main {
+      flex: 1; display: flex; overflow: hidden;
+    }
+    .sidebar {
+      width: 250px; background: var(--bg-panel); border-right: 1px solid var(--border);
+      padding: 1rem; overflow-y: auto;
+    }
+    .chat-area {
+      flex: 1; display: flex; flex-direction: column; background: var(--bg);
+    }
+    .messages {
+      flex: 1; padding: 1.5rem; overflow-y: auto; display: flex; flex-direction: column; gap: 1rem;
+    }
+    .message { max-width: 70%; padding: 0.8rem 1rem; border-radius: 1rem; line-height: 1.4; animation: popIn 0.3s ease-out; }
+    .message.system { max-width: 100%; align-self: center; background: transparent; color: #94a3b8; font-size: 0.9rem; font-style: italic; text-align: center; }
+    .message.self { align-self: flex-end; background: var(--primary); color: #000; border-bottom-right-radius: 0.25rem; }
+    .message.other { align-self: flex-start; background: var(--bg-panel); border-bottom-left-radius: 0.25rem; }
+    .message-header { font-size: 0.75rem; margin-bottom: 0.25rem; opacity: 0.8; }
+    .input-area {
+      padding: 1rem; background: var(--bg-panel); border-top: 1px solid var(--border); display: flex; gap: 1rem;
+    }
+    input[type="text"] {
+      flex: 1; background: var(--bg); border: 1px solid var(--border); color: var(--text);
+      padding: 0.75rem 1rem; border-radius: 0.5rem; outline: none; transition: border-color 0.2s;
+    }
+    input[type="text"]:focus { border-color: var(--primary); }
+    button.send {
+      background: var(--accent); color: white; border: none; padding: 0 1.5rem; border-radius: 0.5rem;
+      font-weight: bold; cursor: pointer; transition: transform 0.1s, opacity 0.2s;
+    }
+    button.send:active { transform: scale(0.95); }
+    @keyframes popIn { from { opacity: 0; transform: translateY(10px); } to { opacity: 1; transform: translateY(0); } }
+    
+    .user-list { list-style: none; padding: 0; margin: 0; display: flex; flex-direction: column; gap: 0.5rem; }
+    .user-item { display: flex; align-items: center; gap: 0.5rem; padding: 0.5rem; border-radius: 0.5rem; background: var(--bg); }
+    .user-item::before { content: ''; width: 8px; height: 8px; border-radius: 50%; background: #22c55e; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>💬 SecureLink Chat <span class="badge" id="conn-count">0 connected</span></h1>
+    <button class="leave-btn" id="leave-btn">Leave Room</button>
+  </header>
+  <main>
+    <div class="sidebar">
+      <h3 style="margin-top:0; font-size: 0.9rem; color: #94a3b8; text-transform: uppercase;">Participants</h3>
+      <ul class="user-list" id="users"></ul>
+    </div>
+    <div class="chat-area">
+      <div class="messages" id="msgs"></div>
+      <form class="input-area" id="chat-form">
+        <input type="text" id="msg-input" placeholder="Type a secure message..." autocomplete="off" disabled>
+        <button type="submit" class="send" id="send-btn" disabled>Send</button>
+      </form>
+    </div>
+  </main>
+
+  <script>
+    const isHost = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1';
+    let username = isHost ? 'Host' : prompt('Enter your name for the chat:', 'Client_' + Math.floor(Math.random()*1000));
+    if (!username) username = 'Anonymous';
+
+    const sessionPassword = window.location.hash.substring(1);
+    if (!sessionPassword) {
+      document.body.innerHTML = '<h2 style="text-align:center; margin-top:20vh; color:red;">Fatal: Missing session password in URL hash. Cannot decrypt E2E chat.</h2>';
+      throw new Error("Missing password");
+    }
+
+    const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const ws = new WebSocket(wsProtocol + '//' + window.location.host);
+
+    const msgs = document.getElementById('msgs');
+    const form = document.getElementById('chat-form');
+    const input = document.getElementById('msg-input');
+    const sendBtn = document.getElementById('send-btn');
+    const leaveBtn = document.getElementById('leave-btn');
+    const usersList = document.getElementById('users');
+    const connCount = document.getElementById('conn-count');
+
+    // ─── Web Crypto E2E AES-GCM ──────────────────────────────────
+    const enc = new TextEncoder();
+    const dec = new TextDecoder();
+
+    function buf2hex(buffer) { return [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, '0')).join(''); }
+    function hex2buf(hexString) { return new Uint8Array(hexString.match(/.{1,2}/g).map(byte => parseInt(byte, 16))); }
+
+    async function deriveKey(password, saltBuffer) {
+      const keyMaterial = await crypto.subtle.importKey(
+        "raw", enc.encode(password), {name: "PBKDF2"}, false, ["deriveBits", "deriveKey"]
+      );
+      return crypto.subtle.deriveKey(
+        { name: "PBKDF2", salt: saltBuffer, iterations: 100000, hash: "SHA-256" },
+        keyMaterial, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]
+      );
+    }
+
+    async function encryptPayload(obj) {
+      const salt = crypto.getRandomValues(new Uint8Array(16));
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const key = await deriveKey(sessionPassword, salt);
+      const ciphertextBuffer = await crypto.subtle.encrypt(
+        { name: "AES-GCM", iv: iv }, key, enc.encode(JSON.stringify(obj))
+      );
+      return {
+        salt: buf2hex(salt),
+        iv: buf2hex(iv),
+        ciphertext: buf2hex(ciphertextBuffer)
+      };
+    }
+
+    async function decryptPayload(encObj) {
+      try {
+        const salt = hex2buf(encObj.salt);
+        const iv = hex2buf(encObj.iv);
+        const ciphertext = hex2buf(encObj.ciphertext);
+        const key = await deriveKey(sessionPassword, salt);
+        const decryptedBuffer = await crypto.subtle.decrypt(
+          { name: "AES-GCM", iv: iv }, key, ciphertext
+        );
+        return JSON.parse(dec.decode(decryptedBuffer));
+      } catch (e) {
+        return null;
+      }
+    }
+
+    // ─── UI Logic ────────────────────────────────────────────────
+    function appendMessage(msg) {
+      const div = document.createElement('div');
+      if (msg.type === 'system') {
+        div.className = 'message system';
+        div.textContent = msg.text;
+      } else {
+        div.className = 'message ' + (msg.sender === username ? 'self' : 'other');
+        div.innerHTML = '<div class="message-header">' + msg.sender + ' • ' + msg.time + '</div><div>' + msg.text + '</div>';
+      }
+      msgs.appendChild(div);
+      msgs.scrollTop = msgs.scrollHeight;
+    }
+
+    function updateUsers(users) {
+      usersList.innerHTML = '';
+      users.forEach(u => {
+        const li = document.createElement('li');
+        li.className = 'user-item';
+        li.textContent = u;
+        usersList.appendChild(li);
+      });
+      connCount.textContent = users.length + ' connected';
+    }
+
+    ws.onopen = async () => {
+      input.disabled = false;
+      sendBtn.disabled = false;
+      input.focus();
+      
+      const encPayload = await encryptPayload({ type: 'join', sender: username });
+      ws.send(JSON.stringify({ type: 'e2e', payload: encPayload }));
+    };
+
+    ws.onmessage = async (event) => {
+      const data = JSON.parse(event.data);
+      if (data.type === 'state') {
+        updateUsers(data.users);
+      } else if (data.type === 'close') {
+        appendMessage({ type: 'system', text: 'The Host has closed the chat room. You may leave now.' });
+        ws.close();
+        input.disabled = true;
+        sendBtn.disabled = true;
+      } else if (data.type === 'e2e') {
+        // Decrypt the incoming E2E message
+        const decrypted = await decryptPayload(data.payload);
+        if (decrypted) {
+          if (decrypted.type === 'join') {
+            appendMessage({ type: 'system', text: \`\${decrypted.sender} has joined the chat (E2E Encrypted)\` });
+          } else if (decrypted.type === 'chat') {
+            appendMessage(decrypted);
+          }
+        }
+      } else {
+        appendMessage(data);
+      }
+    };
+
+    ws.onclose = () => {
+      appendMessage({ type: 'system', text: 'Connection closed.' });
+      input.disabled = true;
+      sendBtn.disabled = true;
+    };
+
+    form.onsubmit = async (e) => {
+      e.preventDefault();
+      const text = input.value.trim();
+      if (!text) return;
+      
+      const msgObj = { type: 'chat', sender: username, text: text, time: new Date().toLocaleTimeString([], {hour: '2-digit', minute:'2-digit'}) };
+      const encPayload = await encryptPayload(msgObj);
+      
+      ws.send(JSON.stringify({ type: 'e2e', payload: encPayload }));
+      input.value = '';
+    };
+
+    leaveBtn.onclick = () => {
+      if (isHost) {
+        if(confirm('Are you sure you want to close the chat room for everyone?')) {
+          ws.send(JSON.stringify({ type: 'host_close' }));
+          window.close();
+        }
+      } else {
+        ws.close();
+        window.close();
+        document.body.innerHTML = '<h2 style="text-align:center; margin-top:20vh;">You have left the chat. You can close this tab.</h2>';
+      }
+    };
+  </script>
+</body>
+</html>
+`;
+
+export async function startChatServer(onClose) {
+  return new Promise((resolve) => {
+    const server = http.createServer((req, res) => {
+      if (req.url === '/') {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(HTML_CONTENT);
+      } else {
+        res.writeHead(404);
+        res.end('Not found');
+      }
+    });
+
+    const wss = new WebSocketServer({ server });
+    const clients = new Map(); // ws -> username
+
+    function broadcastState() {
+      const users = Array.from(clients.values());
+      const payload = JSON.stringify({ type: 'state', users });
+      for (const client of wss.clients) {
+        if (client.readyState === 1) client.send(payload);
+      }
+    }
+
+    function broadcastMsg(msg) {
+      const payload = JSON.stringify(msg);
+      for (const client of wss.clients) {
+        if (client.readyState === 1) client.send(payload);
+      }
+    }
+
+    wss.on('connection', (ws) => {
+      ws.on('message', (message) => {
+        try {
+          const data = JSON.parse(message);
+          
+          if (data.type === 'e2e') {
+            // E2E messages just get forwarded to all clients
+            broadcastMsg(data);
+          } else if (data.type === 'join_event') {
+             // For updating participant count dynamically if we wanted to extract sender, 
+             // but since E2E hides sender, we rely on connection count
+          } else if (data.type === 'host_close') {
+            broadcastMsg({ type: 'close' });
+            server.close();
+            if (onClose) onClose();
+          }
+        } catch (e) {
+          // ignore invalid parse
+        }
+      });
+
+      ws.on('close', () => {
+        // Since we can't read the encrypted username, we just update state
+        clients.delete(ws);
+        broadcastState();
+      });
+    });
+
+    // When connection opens, just assign a generic ID to count them
+    wss.on('connection', (ws) => {
+      clients.set(ws, `User_${Math.floor(Math.random()*1000)}`);
+      broadcastState();
+    });
+
+    server.listen(0, '127.0.0.1', () => {
+      const port = server.address().port;
+      resolve({ port, server });
+    });
+  });
+}
+
+export async function openLocalChatUI(port, password) {
+  try {
+    const chatUrl = `http://localhost:${port}#${password}`;
+    await open(chatUrl);
+  } catch {
+    console.log(chalk.dim(`     Unable to auto-open browser. Visit http://localhost:${port}#${password}`));
+  }
+}