zypher-chat 3.0.0

package/index.js

@@ -0,0 +1,1640 @@
+#!/usr/bin/env node
+'use strict';
+
+const http        = require('http');
+const crypto      = require('crypto');
+const readline    = require('readline');
+const fs          = require('fs');
+const path        = require('path');
+const os          = require('os');
+const { spawn, execSync } = require('child_process');
+
+// ── ANSI helpers ──────────────────────────────────────────────────────────────
+const TTY = !!process.stdout.isTTY;
+const E   = '\x1b[';
+
+const c = {
+    bold:        s => TTY ? `${E}1m${s}${E}0m`  : s,
+    dim:         s => TTY ? `${E}2m${s}${E}0m`  : s,
+    red:         s => TTY ? `${E}31m${s}${E}0m` : s,
+    green:       s => TTY ? `${E}32m${s}${E}0m` : s,
+    yellow:      s => TTY ? `${E}33m${s}${E}0m` : s,
+    cyan:        s => TTY ? `${E}36m${s}${E}0m` : s,
+    white:       s => TTY ? `${E}37m${s}${E}0m` : s,
+    gray:        s => TTY ? `${E}90m${s}${E}0m` : s,
+    brightRed:   s => TTY ? `${E}91m${s}${E}0m` : s,
+    brightGreen: s => TTY ? `${E}92m${s}${E}0m` : s,
+    brightCyan:  s => TTY ? `${E}96m${s}${E}0m` : s,
+    bgRed:       s => TTY ? `${E}41m${s}${E}0m` : s,
+    bgGreen:     s => TTY ? `${E}42m${s}${E}0m` : s,
+    bgYellow:    s => TTY ? `${E}43m${s}${E}0m` : s,
+    magenta:     s => TTY ? `${E}35m${s}${E}0m` : s,
+};
+
+// ── Spinner ───────────────────────────────────────────────────────────────────
+const FRAMES = TTY ? ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'] : ['-','\\','|','/'];
+
+function spin(msg) {
+    let i = 0, text = msg, timer = null;
+    if (TTY) {
+        timer = setInterval(() => {
+            process.stdout.write(`\r  ${c.cyan(FRAMES[i++ % FRAMES.length])}  ${c.dim(text)}`);
+        }, 80);
+    } else {
+        process.stdout.write(`  >> ${text}\n`);
+    }
+    const clear = () => {
+        if (timer) { clearInterval(timer); timer = null; }
+        if (TTY) process.stdout.write('\r\x1b[K');
+    };
+    return {
+        update(t)    { text = t; },
+        ok(m)        { clear(); process.stdout.write(`  ${c.brightGreen('✔')}  ${m || text}\n`); },
+        fail(m)      { clear(); process.stdout.write(`  ${c.brightRed('✖')}  ${m  || text}\n`); },
+        stop()       { clear(); },
+    };
+}
+
+// ── Box drawing ───────────────────────────────────────────────────────────────
+function stripAnsi(s) { return s.replace(/\x1b\[[0-9;]*m/g, ''); }
+
+function box(title, lines) {
+    const rawTitle = stripAnsi(title);
+    const rawLines = lines.map(l => ({ raw: stripAnsi(l), col: l }));
+    const contentW = Math.max(rawTitle.length, ...rawLines.map(l => l.raw.length), 30);
+
+    const dim  = s => TTY ? c.dim(s) : s;
+    const dash = n => dim('─'.repeat(Math.max(0, n)));
+
+    // top: ╭─ Title ──────╮  (between corners = contentW + 4)
+    // 1(─) + 1( ) + rawTitle.length + 1( ) + topFill = contentW + 4
+    const topFill = Math.max(1, contentW - rawTitle.length + 1);
+    const top = `  ${dim('╭')}${dash(1)} ${TTY ? c.bold(c.white(title)) : title} ${dash(topFill)}${dim('╮')}`;
+    const bot = `  ${dim('╰')}${dash(contentW + 4)}${dim('╯')}`;
+    const rows = rawLines.map(({ raw, col }) => {
+        const pad = contentW - raw.length;
+        return `  ${dim('│')}  ${col}${' '.repeat(pad)}  ${dim('│')}`;
+    });
+    return [top, ...rows, bot].join('\n');
+}
+
+// ── Status badge ──────────────────────────────────────────────────────────────
+function badge(type) {
+    const map = {
+        running: () => c.bgGreen(c.bold(' RUNNING ')),
+        stopped: () => c.bgRed(c.bold(' STOPPED ')),
+        ok:      () => c.bgGreen(c.bold('   OK    ')),
+        error:   () => c.bgRed(c.bold('  ERROR  ')),
+        warn:    () => c.bgYellow(c.bold('  WARN   ')),
+    };
+    return TTY ? (map[type] || map.warn)() : `[${type.toUpperCase()}]`;
+}
+
+// ── Horizontal rule ───────────────────────────────────────────────────────────
+function rule(label) {
+    const cols  = Math.min(process.stdout.columns || 72, 72);
+    const mid   = label ? ` ${label} ` : '';
+    const side  = Math.max(2, Math.floor((cols - mid.length - 4) / 2));
+    const left  = c.dim('─'.repeat(side));
+    const right = c.dim('─'.repeat(side));
+    const center = mid ? c.bold(c.cyan(mid)) : '';
+    return `  ${left}${center}${right}`;
+}
+
+// ── Config paths ──────────────────────────────────────────────────────────────
+const CONFIG_DIR  = path.join(os.homedir(), '.zypher');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const SERVER_PID  = path.join(CONFIG_DIR, 'server.pid');
+const SERVER_LOG  = path.join(CONFIG_DIR, 'server.log');
+
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+function loadConfig() {
+    try { ensureConfigDir(); return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); }
+    catch { return { servers: {}, accounts: {} }; }
+}
+
+function saveConfig(cfg) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+
+// ── Readline ──────────────────────────────────────────────────────────────────
+let rl;
+function getRL() {
+    if (!rl || rl.closed) rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return rl;
+}
+
+function ask(prompt) {
+    return new Promise(resolve => getRL().question(prompt, resolve));
+}
+
+function askPassword(prompt) {
+    return new Promise(resolve => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) return getRL().question(prompt, resolve);
+
+        process.stdout.write(prompt);
+        let input = '';
+        let done = false;
+
+        // Pause readline so it doesn't consume raw keystrokes
+        if (rl) rl.pause();
+
+        const onData = buf => {
+            if (done) return;
+            for (const b of buf.toString('utf8')) {
+                if (b === '\r' || b === '\n') {
+                    done = true;
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener('data', onData);
+                    process.stdout.write('\n');
+                    // Resume rl in a setImmediate so the '\n' is flushed to the
+                    // terminal BEFORE readline writes the next prompt — this
+                    // prevents line bleed on Windows cmd/PowerShell
+                    setImmediate(() => { if (rl) rl.resume(); resolve(input); });
+                    return;
+                }
+                if (b === '\u0003') { process.stdin.setRawMode(false); process.stdout.write('\n'); process.exit(0); }
+                if (b === '\u007F' || b === '\b') {
+                    if (input.length) { input = input.slice(0, -1); process.stdout.write('\b \b'); }
+                } else if (b >= ' ') {
+                    input += b;
+                    process.stdout.write(c.dim('•'));
+                }
+            }
+        };
+        try {
+            process.stdin.setRawMode(true);
+            process.stdin.setEncoding('utf8');
+            process.stdin.resume();
+            process.stdin.on('data', onData);
+        } catch { if (rl) rl.resume(); getRL().question(prompt, resolve); }
+    });
+}
+
+// ── HTTP API ──────────────────────────────────────────────────────────────────
+function apiRequest(serverUrl, method, urlPath, body, token) {
+    return new Promise((resolve, reject) => {
+        let parsed;
+        try { parsed = new URL(serverUrl); }
+        catch { return reject(new Error(`Invalid server URL: ${serverUrl}`)); }
+
+        const hostname = parsed.hostname;
+        const port     = parseInt(parsed.port || (parsed.protocol === 'https:' ? '443' : '80'), 10);
+        const payload  = body ? JSON.stringify(body) : null;
+        const req = http.request({
+            hostname, port, path: urlPath, method,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(token   && { Authorization:    `Bearer ${token}` }),
+                ...(payload && { 'Content-Length': Buffer.byteLength(payload) }),
+            },
+        }, res => {
+            let raw = '';
+            res.on('data', d => raw += d);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(raw);
+                    if (res.statusCode >= 400) reject(new Error(json.error || raw));
+                    else resolve(json);
+                } catch { reject(new Error(raw || `HTTP ${res.statusCode}`)); }
+            });
+        });
+        req.setTimeout(8000, () => req.destroy(new Error('Connection timed out')));
+        req.on('error', reject);
+        if (payload) req.write(payload);
+        req.end();
+    });
+}
+
+// ── Crypto ────────────────────────────────────────────────────────────────────
+function generateKeyPairs() {
+    const identity = crypto.generateKeyPairSync('ed25519', {
+        publicKeyEncoding:  { type: 'spki',  format: 'der' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'der' },
+    });
+    const preKey = crypto.generateKeyPairSync('x25519', {
+        publicKeyEncoding:  { type: 'spki',  format: 'der' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'der' },
+    });
+    return {
+        identityPubKey:  identity.publicKey.toString('base64'),
+        identityPrivKey: identity.privateKey.toString('base64'),
+        preKeyPub:       preKey.publicKey.toString('base64'),
+        preKeyPriv:      preKey.privateKey.toString('base64'),
+    };
+}
+
+function ecdhKey(privB64, pubB64) {
+    const priv = crypto.createPrivateKey({ key: Buffer.from(privB64, 'base64'), format: 'der', type: 'pkcs8' });
+    const pub  = crypto.createPublicKey ({ key: Buffer.from(pubB64,  'base64'), format: 'der', type: 'spki'  });
+    const dh   = crypto.diffieHellman({ privateKey: priv, publicKey: pub });
+    // HKDF-SHA256: proper KDF with domain separation — stronger than raw SHA256
+    return Buffer.from(crypto.hkdfSync('sha256', dh, Buffer.alloc(32), Buffer.from('zypher-x25519-v1'), 32));
+}
+
+function encryptMsg(plaintext, keyBuf, aad = '') {
+    const nonce  = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', keyBuf, nonce);
+    if (aad) cipher.setAAD(Buffer.from(aad));
+    const enc    = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const tag    = cipher.getAuthTag();
+    return { ciphertext: Buffer.concat([enc, tag]).toString('base64'), nonce: nonce.toString('base64') };
+}
+
+function decryptMsg(ctB64, nonceB64, keyBuf, aad = '') {
+    const buf    = Buffer.from(ctB64,    'base64');
+    const nonce  = Buffer.from(nonceB64, 'base64');
+    const tag    = buf.slice(buf.length - 16);
+    const enc    = buf.slice(0, buf.length - 16);
+    const d      = crypto.createDecipheriv('aes-256-gcm', keyBuf, nonce);
+    if (aad) d.setAAD(Buffer.from(aad));
+    d.setAuthTag(tag);
+    return Buffer.concat([d.update(enc), d.final()]).toString('utf8');
+}
+
+// Ed25519 message signing — proves authorship, prevents server from forging or tampering
+function signMsg(data, privB64) {
+    const key = crypto.createPrivateKey({ key: Buffer.from(privB64, 'base64'), format: 'der', type: 'pkcs8' });
+    return crypto.sign(null, Buffer.from(data), key).toString('base64');
+}
+
+function verifyMsg(data, sigB64, pubB64) {
+    try {
+        const key = crypto.createPublicKey({ key: Buffer.from(pubB64, 'base64'), format: 'der', type: 'spki' });
+        return crypto.verify(null, Buffer.from(data), key, Buffer.from(sigB64, 'base64'));
+    } catch { return false; }
+}
+
+// Per-session identity key cache — populated when keys are fetched, used for signature verification
+const keysCache = new Map();
+
+// ── Notifications & unread tracking ────────────────────────────────────────────
+const currentChat = { type: null, with: null }; // 'dm' | 'group' | null
+const unreadBuf   = { dms: {}, groups: {} };    // buffered cross-chat messages
+
+function notify(from, preview) {
+    process.stdout.write('\x07'); // terminal bell
+    if (TTY) {
+        const orig = process.title;
+        process.title = `[!] ${from}: ${String(preview || '').slice(0, 40)}`;
+        setTimeout(() => { try { process.title = orig; } catch {} }, 4000);
+    }
+}
+
+function showNotifBanner(from, groupName) {
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    const who = groupName
+        ? `${c.bold(c.green(from))} ${c.dim('in')} ${c.bold(c.magenta('@' + groupName))}`
+        : c.bold(c.green(from));
+    const total = Object.values(unreadBuf.dms).reduce((s, a) => s + a.length, 0)
+                + Object.values(unreadBuf.groups).reduce((s, a) => s + a.length, 0);
+    process.stdout.write(
+        `  ${c.bgYellow(c.bold(' NEW '))} ${who} ${c.dim('wrote')}` +
+        (total > 1 ? c.dim(` · ${total} unread`) : '') + '\n' +
+        c.dim('  /inbox to read\n\n')
+    );
+    if (currentChat.type !== null) getRL().prompt(true);
+}
+
+// ── Group crypto helpers ──────────────────────────────────────────────────────
+// Encrypt a 32-byte group key for a specific user using their X25519 pre-key.
+// Returns { ratchetKey, encKey, nonce } — all base64.
+function encryptGroupKeyForUser(groupKeyBuf, theirPreKeyPub) {
+    const eph = crypto.generateKeyPairSync('x25519', {
+        publicKeyEncoding:  { type: 'spki',  format: 'der' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'der' },
+    });
+    const ratchetKey  = eph.publicKey.toString('base64');
+    const ratchetPriv = eph.privateKey.toString('base64');
+    const aesKey = ecdhKey(ratchetPriv, theirPreKeyPub);
+    const { ciphertext: encKey, nonce } = encryptMsg(groupKeyBuf.toString('hex'), aesKey, 'zypher-group-key-bundle-v1');
+    return { ratchetKey, encKey, nonce };
+}
+
+// Decrypt a group key bundle, returning the raw 32-byte Buffer.
+function decryptGroupKey(bundle, myPreKeyPriv) {
+    const aesKey = ecdhKey(myPreKeyPriv, bundle.ratchetKey);
+    const keyHex = decryptMsg(bundle.encKey, bundle.nonce, aesKey, 'zypher-group-key-bundle-v1');
+    return Buffer.from(keyHex, 'hex');
+}
+
+// ── Promisified spawn ─────────────────────────────────────────────────────────
+const NPM = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+
+function spawnAsync(cmd, args, opts) {
+    return new Promise((resolve, reject) => {
+        // On Windows, .cmd/.bat files must be run through the shell
+        const isWin = process.platform === 'win32';
+        const child = spawn(cmd, args, { stdio: 'pipe', shell: isWin, ...opts });
+        let stderr = '';
+        if (child.stderr) child.stderr.on('data', d => { stderr += d.toString(); });
+        child.on('error', reject);
+        child.on('close', code => code === 0 ? resolve() : reject(new Error(stderr.trim() || `${cmd} exited ${code}`)));
+    });
+}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+// ── Banner ────────────────────────────────────────────────────────────────────
+function printBanner() {
+    const art = [
+        '  ______         _                 ',
+        ' |___  /        | |                ',
+        "    / / _   _ _ | |__   ___ _ __   ",
+        "   / / | | | | \\| '_ \\ / _ \\ '__|",
+        '  / /__| |_| | |_| | | |  __/ |   ',
+        ' /_____\\__,  |\\__,_| |_|\\___|_| ',
+    ];
+    process.stdout.write('\n');
+    for (const line of art) process.stdout.write(c.cyan(line) + '\n');
+    process.stdout.write(c.dim('        __/ |') + c.bold(c.white('    ghost e2ee cli   ')) + '\n');
+    process.stdout.write(c.dim('       |___/') + c.gray('  v3  ·  zero-knowledge  ·  forward-secrecy') + '\n\n');
+}
+
+function printHelp() {
+    printBanner();
+    process.stdout.write(rule('commands') + '\n\n');
+    const cmds = [
+        [c.bold(c.cyan('zypher server quickstart')), 'Clone, configure & launch a Zypher server daemon'],
+        [c.bold(c.cyan('zypher server stop')),       'Stop the running server daemon'],
+        [c.bold(c.cyan('zypher server status')),     'Show server daemon status'],
+        [c.bold(c.cyan('zypher new')),               'Add a server and register / login'],
+        [c.bold(c.cyan('zypher <server> [user]')),   'Open E2EE chat on a saved server'],
+        [c.bold(c.cyan('zypher settings')),          'Manage servers, accounts, ghost mode'],
+        [c.bold(c.cyan('zypher help')),              'Show this help'],
+    ];
+    for (const [cmd, desc] of cmds) {
+        process.stdout.write(`    ${cmd}\n`);
+        process.stdout.write(`      ${c.dim(desc)}\n\n`);
+    }
+    process.stdout.write(rule('examples') + '\n\n');
+    for (const ex of ['zypher server quickstart', 'zypher new', 'zypher local', 'zypher local alice', 'zypher settings'])
+        process.stdout.write(`    ${c.dim('$')} ${c.green(ex)}\n`);
+    process.stdout.write('\n');
+}
+
+// ── zypher server quickstart ──────────────────────────────────────────────────
+async function cmdServerQuickstart() {
+    printBanner();
+    process.stdout.write(rule('server quickstart') + '\n\n');
+    process.stdout.write(c.dim('  Press Enter to keep defaults shown in [ ].\n\n'));
+
+    const portRaw    = (await ask(`  ${c.bold('Port')}               ${c.dim('[3000]')} : `)).trim();
+    const masterPass = await askPassword(`  ${c.bold('Master password')}                : `);
+    const rlRaw      = (await ask(`  ${c.bold('Rate limit')} (req/min) ${c.dim('[100]')} : `)).trim();
+    const bodyRaw    = (await ask(`  ${c.bold('Max body size')}         ${c.dim('[1mb]')} : `)).trim();
+    process.stdout.write('\n');
+
+    if (!masterPass) {
+        process.stdout.write(`  ${c.brightRed('✖')}  Master password cannot be empty.\n\n`);
+        process.exit(1);
+    }
+
+    const port        = Math.max(1, Math.min(65535, parseInt(portRaw  || '3000', 10)));
+    const rateLimit   = Math.max(1, parseInt(rlRaw || '100', 10));
+    const maxBodySize = bodyRaw || '1mb';
+    const jwtSecret   = crypto.randomBytes(32).toString('hex');
+
+    ensureConfigDir();
+
+    // ── 1. Check git ──────────────────────────────────────────────────────────
+    {
+        const s = spin('Checking for git…');
+        try { execSync('git --version', { stdio: 'pipe' }); s.ok('git is available'); }
+        catch { s.fail('git not found — install git and retry'); process.exit(1); }
+    }
+
+    // ── 2. Clone repo ─────────────────────────────────────────────────────────
+    const cloneDir = path.resolve(process.cwd(), 'zypher');
+    if (fs.existsSync(cloneDir)) {
+        process.stdout.write(`\n  ${c.yellow('!')}  ${c.bold(cloneDir)} already exists.\n`);
+        const ans = (await ask(`  ${c.dim('Overwrite? [y/N] : ')}`)).trim().toLowerCase();
+        process.stdout.write('\n');
+        if (ans !== 'y') { process.stdout.write('  Aborted.\n\n'); process.exit(0); }
+        const s = spin('Removing old directory…');
+        fs.rmSync(cloneDir, { recursive: true, force: true });
+        s.ok('Old directory removed');
+    }
+
+    {
+        const s = spin('Cloning real-kijmoshi/zypher from GitHub…');
+        try {
+            await spawnAsync('git', ['clone', 'https://github.com/real-kijmoshi/zypher', cloneDir]);
+            s.ok('Repository cloned');
+        } catch (err) { s.fail(`Clone failed: ${err.message}`); process.exit(1); }
+    }
+
+    // ── 3. Remove client folder from clone ────────────────────────────────────
+    {
+        const s = spin('Removing client folder from clone…');
+        const clientDir = path.join(cloneDir, 'client');
+        if (fs.existsSync(clientDir)) fs.rmSync(clientDir, { recursive: true, force: true });
+        s.ok('Client folder removed');
+    }
+
+    // ── 4. npm install ────────────────────────────────────────────────────────
+    const serverDir = path.join(cloneDir, 'server');
+    if (!fs.existsSync(serverDir)) {
+        process.stdout.write(`\n  ${c.brightRed('✖')}  No server/ folder in cloned repo.\n\n`);
+        process.exit(1);
+    }
+
+    {
+        const s = spin('Installing server dependencies…');
+        try {
+            await spawnAsync(NPM, ['install', '--prefer-offline', '--no-audit', '--no-fund'], { cwd: serverDir });
+            s.ok('Dependencies installed');
+        } catch (err) { s.fail(`npm install failed: ${err.message}`); process.exit(1); }
+    }
+
+    // ── 5. Write server config ────────────────────────────────────────────────
+    const serverCfgPath = path.join(CONFIG_DIR, 'server-config.json');
+    const cfgObj = { port, masterPassword: masterPass, jwtSecret, rateLimit, maxBodySize, serverDir };
+    fs.writeFileSync(serverCfgPath, JSON.stringify(cfgObj, null, 2), { mode: 0o600 });
+
+    // Also write a .env in the server directory so dotenv-based servers work
+    const envContent = [
+        `PORT=${port}`,
+        `MASTER_PASSWORD=${masterPass}`,
+        `JWT_SECRET=${jwtSecret}`,
+        `RATE_LIMIT=${rateLimit}`,
+        `MAX_BODY_SIZE=${maxBodySize}`,
+    ].join('\n') + '\n';
+    fs.writeFileSync(path.join(serverDir, '.env'), envContent, { mode: 0o600 });
+    process.stdout.write(`  ${c.dim('·')}  Config written\n`);
+
+    // ── 6. Kill old daemon ────────────────────────────────────────────────────
+    try {
+        const oldPid = parseInt(fs.readFileSync(SERVER_PID, 'utf8').trim(), 10);
+        process.kill(oldPid, 0);
+        process.kill(oldPid);
+        process.stdout.write(`  ${c.dim('↑')}  Stopped previous daemon (PID ${oldPid})\n`);
+    } catch { /* not running */ }
+
+    // ── 7. Daemonize ─────────────────────────────────────────────────────────
+    const serverScript = path.join(serverDir, 'index.js');
+    if (!fs.existsSync(serverScript)) {
+        process.stdout.write(`\n  ${c.brightRed('✖')}  server/index.js not found in clone.\n\n`);
+        process.exit(1);
+    }
+
+    const logFd = fs.openSync(SERVER_LOG, 'a');
+    const child = spawn(process.execPath, [serverScript], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: { ...process.env, ZYPHER_CONFIG: serverCfgPath },
+    });
+    child.unref();
+    fs.closeSync(logFd);
+    fs.writeFileSync(SERVER_PID, String(child.pid));
+
+    // ── 8. Health check ───────────────────────────────────────────────────────
+    {
+        const s = spin('Waiting for server to come online…');
+        await sleep(900);
+        try {
+            await apiRequest(`http://localhost:${port}`, 'GET', '/health', null, null);
+            s.ok(`Server is online`);
+        } catch { s.fail('Server started but /health failed — check the log'); }
+    }
+
+    process.stdout.write('\n');
+    const aliasInput = (await ask(`  ${c.bold('Save server as alias')}  ${c.dim('[local]')} : `)).trim() || 'local';
+    process.stdout.write('\n');
+
+    const cfg = loadConfig();
+    cfg.servers[aliasInput] = { url: `http://localhost:${port}`, alias: aliasInput };
+    saveConfig(cfg);
+
+    process.stdout.write(box('server started', [
+        `${c.dim('Status')}  ${badge('running')}`,
+        `${c.dim('PID   ')}  ${c.bold(String(child.pid))}`,
+        `${c.dim('Port  ')}  ${c.bold(String(port))}`,
+        `${c.dim('Alias ')}  ${c.bold(c.cyan(aliasInput))}`,
+        `${c.dim('Dir   ')}  ${c.gray(cloneDir)}`,
+        `${c.dim('Log   ')}  ${c.gray(SERVER_LOG)}`,
+        '',
+        `Connect  ${c.bold(c.green(`zypher ${aliasInput}`))}`,
+        `Stop     ${c.bold(c.green('zypher server stop'))}`,
+    ]) + '\n\n');
+
+    // Offer to create the first account right now
+    const createNow = (await ask(`  ${c.bold('Create first account on this server?')} ${c.dim('[Y/n]')} : `)).trim().toLowerCase();
+    process.stdout.write('\n');
+    if (createNow !== 'n') {
+        await doRegister(cfg, aliasInput, `http://localhost:${port}`);
+    }
+
+    getRL().close();
+}
+
+// ── zypher server stop ────────────────────────────────────────────────────────
+function cmdServerStop() {
+    try {
+        const pid = parseInt(fs.readFileSync(SERVER_PID, 'utf8').trim(), 10);
+        process.kill(pid);
+        fs.unlinkSync(SERVER_PID);
+        process.stdout.write(`\n  ${c.brightGreen('✔')}  Server (PID ${c.bold(String(pid))}) ${badge('stopped')}\n\n`);
+    } catch {
+        process.stdout.write(`\n  ${c.dim('·')}  No running server found.\n\n`);
+    }
+}
+
+// ── zypher server status ──────────────────────────────────────────────────────
+function cmdServerStatus() {
+    try {
+        const pid = parseInt(fs.readFileSync(SERVER_PID, 'utf8').trim(), 10);
+        process.kill(pid, 0);
+        let port = '?';
+        try { port = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, 'server-config.json'), 'utf8')).port; } catch {}
+        process.stdout.write(`\n  ${badge('running')}  PID ${c.bold(String(pid))}  ·  port ${c.bold(String(port))}\n\n`);
+    } catch {
+        process.stdout.write(`\n  ${badge('stopped')}  Server is not running.\n\n`);
+    }
+}
+
+// ── zypher new ────────────────────────────────────────────────────────────────
+async function cmdNew() {
+    printBanner();
+    process.stdout.write(rule('add server') + '\n\n');
+
+    const cfg      = loadConfig();
+    let urlRaw = (await ask(`  ${c.bold('Server URL')}   ${c.dim('[http://localhost:3000]')} : `)).trim() || 'http://localhost:3000';
+
+    // Normalize: strip trailing slashes, add http:// if no scheme given,
+    // and collapse accidental double-scheme (e.g. http://http://...)
+    urlRaw = urlRaw.replace(/\/+$/, '');
+    if (!/^https?:\/\//i.test(urlRaw)) urlRaw = 'http://' + urlRaw;
+    // Collapse double scheme
+    urlRaw = urlRaw.replace(/^(https?:\/\/)+/i, m => m.slice(0, m.indexOf('://') + 3));
+    const urlInput = urlRaw;
+
+    const alias    = (await ask(`  ${c.bold('Alias')}                                     : `)).trim();
+    process.stdout.write('\n');
+
+    if (!alias) {
+        process.stdout.write(`  ${c.brightRed('✖')}  Alias cannot be empty.\n\n`);
+        getRL().close(); return;
+    }
+    try { new URL(urlInput); } catch {
+        process.stdout.write(`  ${c.brightRed('✖')}  Invalid URL format.\n\n`);
+        getRL().close(); return;
+    }
+
+    const s = spin(`Connecting to ${urlInput}…`);
+    try {
+        await apiRequest(urlInput, 'GET', '/health', null, null);
+        s.ok(`${c.brightGreen('Reachable')}  ${c.gray(urlInput)}`);
+    } catch (err) {
+        const offline = err.message.includes('timed out') || err.message.includes('ECONNREFUSED');
+        s.fail(offline ? `Offline — server unreachable, saved anyway` : `${err.message}`);
+    }
+
+    cfg.servers[alias] = { url: urlInput, alias };
+    saveConfig(cfg);
+
+    process.stdout.write('\n');
+    process.stdout.write(`  ${c.bold(c.cyan('1'))}  Register a new account on this server\n`);
+    process.stdout.write(`  ${c.bold(c.cyan('2'))}  Login with an existing account\n`);
+    process.stdout.write(`  ${c.bold(c.cyan('3'))}  Save and quit\n`);
+    const choice = (await ask(`\n  ${c.dim('›')} `)).trim();
+    process.stdout.write('\n');
+
+    if      (choice === '1') await doRegister(cfg, alias, urlInput);
+    else if (choice === '2') await doLogin(cfg, alias, urlInput);
+    else process.stdout.write(`  ${c.dim('·')}  Saved "${alias}". Use ${c.cyan(`zypher ${alias}`)} to connect.\n\n`);
+
+    getRL().close();
+}
+
+// ── Register ──────────────────────────────────────────────────────────────────
+async function doRegister(cfg, serverAlias, serverUrl) {
+    process.stdout.write(rule('register') + '\n\n');
+    const username = (await ask(`  ${c.bold('Username')}        : `)).trim();
+    const password = await askPassword(`  ${c.bold('Password')}        : `);
+    const master   = await askPassword(`  ${c.bold('Master password')} : `);
+    process.stdout.write('\n');
+
+    if (!username || !password || !master) {
+        process.stdout.write(`  ${c.brightRed('✖')}  All fields are required.\n\n`); return;
+    }
+
+    const keys = generateKeyPairs();
+    const s    = spin('Registering…');
+    try {
+        await apiRequest(serverUrl, 'POST', '/register', {
+            username, password, masterPassword: master,
+            identityKey: keys.identityPubKey, preKey: keys.preKeyPub,
+        });
+        s.stop();
+    } catch (err) { s.fail(`Registration failed: ${err.message}`); return; }
+
+    let token = '';
+    try { token = (await apiRequest(serverUrl, 'POST', '/login', { username, password })).token; } catch {}
+
+    if (!cfg.accounts[serverAlias]) cfg.accounts[serverAlias] = {};
+    cfg.accounts[serverAlias][username] = { keys, token };
+    saveConfig(cfg);
+
+    process.stdout.write(box('registered', [
+        `${c.dim('User  ')}  ${c.bold(c.cyan(username))}`,
+        `${c.dim('Server')}  ${c.bold(serverAlias)}`,
+        '',
+        `Connect  ${c.bold(c.green(`zypher ${serverAlias} ${username}`))}`,
+    ]) + '\n\n');
+}
+
+// ── Login ─────────────────────────────────────────────────────────────────────
+async function doLogin(cfg, serverAlias, serverUrl) {
+    process.stdout.write(rule('login') + '\n\n');
+    const username = (await ask(`  ${c.bold('Username')} : `)).trim();
+    const password = await askPassword(`  ${c.bold('Password')} : `);
+    process.stdout.write('\n');
+
+    const s = spin('Authenticating…');
+    let res;
+    try { res = await apiRequest(serverUrl, 'POST', '/login', { username, password }); s.stop(); }
+    catch (err) { s.fail(`Login failed: ${err.message}`); return; }
+
+    if (!cfg.accounts[serverAlias]) cfg.accounts[serverAlias] = {};
+    const existing = cfg.accounts[serverAlias][username] || {};
+
+    // If there are no local private keys for this account (e.g. first login on
+    // this machine), generate a fresh key pair and push the public keys to the
+    // server so future messages can be encrypted to us.
+    let keys = existing.keys;
+    if (!keys) {
+        process.stdout.write(`\n  ${c.yellow('!')}  No local keys — generating new key pair and uploading to server.\n`);
+        process.stdout.write(c.dim('  Messages sent before this re-key cannot be decrypted on this device.\n\n'));
+        keys = generateKeyPairs();
+        const sk = spin('Uploading new public keys…');
+        try {
+            await apiRequest(serverUrl, 'PUT', '/keys', {
+                identityKey: keys.identityPubKey,
+                preKey:      keys.preKeyPub,
+            }, res.token);
+            sk.ok('Public keys updated on server');
+        } catch (e) {
+            sk.fail(`Re-key failed: ${e.message}`);
+        }
+    }
+
+    cfg.accounts[serverAlias][username] = { ...existing, keys, token: res.token };
+    saveConfig(cfg);
+
+    process.stdout.write(`\n  ${c.brightGreen('✔')}  Logged in as ${c.bold(c.cyan(username))} on ${c.bold(serverAlias)}\n`);
+    process.stdout.write(`  ${c.dim('Connect:')}  ${c.green(`zypher ${serverAlias} ${username}`)}\n\n`);
+}
+
+// ── zypher <server> [user] ────────────────────────────────────────────────────
+async function cmdConnect(serverAlias, usernameArg) {
+    const cfg      = loadConfig();
+    const server   = cfg.servers[serverAlias];
+
+    if (!server) {
+        process.stdout.write(`\n  ${c.brightRed('✖')}  Unknown server ${c.bold(`"${serverAlias}"`)}\n`);
+        process.stdout.write(`  ${c.dim('Use')} ${c.cyan('zypher new')} ${c.dim('to add a server.')}\n\n`);
+        process.exit(1);
+    }
+
+    let username = usernameArg;
+    const accounts = Object.keys(cfg.accounts?.[serverAlias] || {});
+
+    if (!username) {
+        if (!accounts.length) {
+            process.stdout.write(`\n  ${c.brightRed('✖')}  No accounts for "${serverAlias}". Use ${c.cyan('zypher new')}.\n\n`);
+            process.exit(1);
+        }
+        if (accounts.length === 1) {
+            username = accounts[0];
+        } else {
+            printBanner();
+            process.stdout.write(rule(`accounts on ${serverAlias}`) + '\n\n');
+            accounts.forEach((u, i) => process.stdout.write(`  ${c.bold(c.cyan(String(i + 1)))}  ${u}\n`));
+            const idx = parseInt((await ask(`\n  ${c.dim('›')} `)).trim(), 10) - 1;
+            username  = accounts[Math.max(0, Math.min(idx, accounts.length - 1))];
+            process.stdout.write('\n');
+        }
+    }
+
+    const account = cfg.accounts?.[serverAlias]?.[username];
+    if (!account) {
+        process.stdout.write(`\n  ${c.brightRed('✖')}  No stored account "${username}" on "${serverAlias}".\n\n`);
+        process.exit(1);
+    }
+
+    let { token, keys } = account;
+
+    const tryRelogin = async () => {
+        const password = await askPassword(`  ${c.bold('Password')} : `);
+        process.stdout.write('\n');
+        const res = await apiRequest(server.url, 'POST', '/login', { username, password });
+        token = res.token;
+        cfg.accounts[serverAlias][username].token = token;
+        saveConfig(cfg);
+    };
+
+    if (token) {
+        try { await apiRequest(server.url, 'GET', `/keys/${username}`, null, token); }
+        catch (err) {
+            if (/invalid token|missing token|auth/i.test(err.message)) {
+                process.stdout.write(`  ${c.yellow('!')}  Session expired — re-enter password.\n`);
+                try { await tryRelogin(); }
+                catch (e) { process.stdout.write(`  ${c.brightRed('✖')}  Re-login: ${e.message}\n\n`); process.exit(1); }
+            }
+        }
+    } else {
+        process.stdout.write(`  ${c.yellow('!')}  No session — please log in.\n`);
+        try { await tryRelogin(); }
+        catch (e) { process.stdout.write(`  ${c.brightRed('✖')}  Login: ${e.message}\n\n`); process.exit(1); }
+    }
+
+    if (!keys) {
+        process.stdout.write(`\n  ${c.brightRed('✖')}  No local keys. Register on this machine via ${c.cyan('zypher new')}.\n\n`);
+        process.exit(1);
+    }
+
+    await runChat(server.url, serverAlias, username, token, keys);
+}
+
+// ── Chat ──────────────────────────────────────────────────────────────────────
+async function runChat(serverUrl, serverAlias, username, token, myKeys) {
+    // Seed the key cache with our own identity key
+    keysCache.set(username, myKeys.identityPubKey);
+    let ioClient;
+    try { ioClient = require('socket.io-client'); }
+    catch {
+        process.stdout.write(`\n  ${c.brightRed('✖')}  socket.io-client not installed.\n  Run: ${c.cyan('npm install')} inside the client/ folder.\n\n`);
+        process.exit(1);
+    }
+
+    // Connect socket first so background notifications work immediately.
+    const socket = ioClient(serverUrl, { auth: { token } });
+    socket.on('connect_error', err => process.stdout.write(`\n  ${c.brightRed('✖')}  Socket: ${err.message}\n`));
+
+    // Always-on: show group invite notifications in any chat mode.
+    socket.on('group_invite', ({ groupName, invitedBy }) => {
+        notify(invitedBy, `invited you to @${groupName}`);
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        process.stdout.write(
+            `  ${c.bgYellow(c.bold(' GROUP INVITE '))}  ${c.bold(c.green(invitedBy))} ` +
+            `added you to ${c.bold(c.cyan('@' + groupName))}\n` +
+            c.dim(`  Chat with: @${groupName} to open it\n\n`)
+        );
+        if (currentChat.type !== null) getRL().prompt(true);
+    });
+
+    // Background: DMs that arrive while AFK, at the "Chat with" prompt, or in group chat
+    socket.on('receive_message', msg => {
+        if (currentChat.type === 'dm' && currentChat.with === msg.from) return;
+        if (!unreadBuf.dms[msg.from]) unreadBuf.dms[msg.from] = [];
+        unreadBuf.dms[msg.from].push(msg);
+        notify(msg.from, '…');
+        showNotifBanner(msg.from, null);
+    });
+
+    // Background: group messages that arrive while AFK, at the "Chat with" prompt, or in 1:1 chat
+    socket.on('receive_group_message', msg => {
+        if (msg.from === username) return;
+        if (currentChat.type === 'group' && currentChat.with === msg.groupName) return;
+        if (!unreadBuf.groups[msg.groupName]) unreadBuf.groups[msg.groupName] = [];
+        unreadBuf.groups[msg.groupName].push(msg);
+        notify(msg.from, `@${msg.groupName}`);
+        showNotifBanner(msg.from, msg.groupName);
+    });
+
+    // ── Lobby ─────────────────────────────────────────────────────────────────
+    {
+        const w = Math.min(process.stdout.columns || 72, 72);
+        process.stdout.write('\n' + c.dim('─'.repeat(w)) + '\n');
+        process.stdout.write(
+            `  ${c.bold(c.cyan(serverAlias))} ${c.dim('·')} ${c.bold(username)} ` +
+            `${c.bgGreen(c.bold(' E2EE '))}\n`
+        );
+        // Show online users + my groups (parallel)
+        let onlineUsers = [];
+        let myGroups = [];
+        try {
+            const [onlineRes, groupsRes] = await Promise.allSettled([
+                apiRequest(serverUrl, 'GET', '/online', null, token),
+                apiRequest(serverUrl, 'GET', '/groups', null, token),
+            ]);
+            if (onlineRes.status === 'fulfilled') {
+                onlineUsers = (onlineRes.value.online || []).filter(u => u !== username);
+            }
+            if (groupsRes.status === 'fulfilled') {
+                myGroups = groupsRes.value.groups || [];
+            }
+        } catch { /* non-fatal */ }
+
+        if (onlineUsers.length) {
+            process.stdout.write(
+                `  ${c.dim('online:')} ` +
+                onlineUsers.map(u => {
+                    const badge = unreadBuf.dms[u] ? c.bgYellow(c.bold(` ${unreadBuf.dms[u].length} `)) : '';
+                    return c.bold(c.green('● ')) + c.bold(u) + badge;
+                }).join(c.dim('  ')) + '\n'
+            );
+        }
+        // Offline users with pending unread DMs
+        const offlineUnread = Object.keys(unreadBuf.dms).filter(u => !onlineUsers.includes(u));
+        if (offlineUnread.length) {
+            process.stdout.write(
+                `  ${c.dim('unread:')} ` +
+                offlineUnread.map(u => c.bold(u) + c.bgYellow(c.bold(` ${unreadBuf.dms[u].length} `))).join(c.dim('  ')) + '\n'
+            );
+        }
+        if (myGroups.length) {
+            process.stdout.write(
+                `  ${c.dim('groups:')} ` +
+                myGroups.map(g => {
+                    const badge = unreadBuf.groups[g.name] ? c.bgYellow(c.bold(` ${unreadBuf.groups[g.name].length} `)) : '';
+                    return c.bold(c.magenta('@' + g.name)) + badge;
+                }).join(c.dim('  ')) + '\n'
+            );
+        }
+        process.stdout.write(c.dim('─'.repeat(w)) + '\n\n');
+    }
+
+    const recipient = (await ask(`  ${c.bold('Chat with')} ${c.dim('(name, @group, or leave blank to quit)')} : `)).trim();
+    if (!recipient) { socket.disconnect(); process.stdout.write('  Disconnected.\n\n'); process.exit(0); }
+
+    // Route to group chat when prefixed with @
+    if (recipient.startsWith('@')) {
+        await runGroupChat(serverUrl, serverAlias, username, token, myKeys, socket, recipient.slice(1));
+        return;
+    }
+
+    // ── 1:1 chat ─────────────────────────────────────────────────────────────
+    currentChat.type = 'dm';
+    currentChat.with = recipient;
+
+    const s = spin(`Fetching ${recipient}'s keys…`);
+    let theirKeys;
+    try {
+        theirKeys = await apiRequest(serverUrl, 'GET', `/keys/${recipient}`, null, token);
+        keysCache.set(recipient, theirKeys.identityKey);  // cache for signature verification
+        s.ok(`Keys fetched for ${c.bold(recipient)}`);
+    } catch (err) { s.fail(`Could not fetch keys for "${recipient}": ${err.message}`); socket.disconnect(); getRL().close(); return; }
+
+    // Show header + request offline queue once connected (guard against socket
+    // already being connected while we waited for user input above).
+    const initOneToOne = () => {
+        const w = Math.min(process.stdout.columns || 72, 72);
+        process.stdout.write('\n' + c.dim('─'.repeat(w)) + '\n');
+        process.stdout.write(
+            `  ${c.bold(c.cyan(serverAlias))} ${c.dim('/')} ${c.bold(username)} ` +
+            `${c.dim('→')} ${c.bold(c.green(recipient))} ` +
+            `${c.bgGreen(c.bold(' E2EE '))}\n`
+        );
+        process.stdout.write(
+            c.dim('  /chat <name|@group>  switch  · /who  · /keys  · /status  · /groups  · /inbox  · /help\n')
+        );
+        process.stdout.write(c.dim('─'.repeat(w)) + '\n\n');
+        socket.emit('fetch_messages');
+    };
+    if (socket.connected) initOneToOne();
+    else socket.once('connect', initOneToOne);
+
+    socket.on('message_history', msgs => {
+        if (msgs.length) {
+            process.stdout.write(c.dim(`  ── ${msgs.length} queued ──\n`));
+            for (const m of msgs) renderMsg(m, myKeys.preKeyPriv, username);
+            process.stdout.write(c.dim('  ─────────────\n\n'));
+        }
+        // Show cross-chat unread summary collected before we entered this chat
+        const dmTotal  = Object.values(unreadBuf.dms).reduce((s, a) => s + a.length, 0);
+        const grpTotal = Object.values(unreadBuf.groups).reduce((s, a) => s + a.length, 0);
+        if (dmTotal || grpTotal) {
+            const parts = [];
+            if (dmTotal)  parts.push(`${dmTotal} unread DM${dmTotal  === 1 ? '' : 's'} from ${Object.keys(unreadBuf.dms).join(', ')}`);
+            if (grpTotal) parts.push(`${grpTotal} group msg${grpTotal === 1 ? '' : 's'} in ${Object.keys(unreadBuf.groups).map(g => '@' + g).join(', ')}`);
+            process.stdout.write(`  ${c.bgYellow(c.bold(' UNREAD '))} ${c.dim(parts.join(' · '))} ${c.dim('· /inbox to read')}\n\n`);
+        }
+        getRL().setPrompt(`  ${c.bold(c.cyan('you'))} ${c.dim('›')} `);
+        getRL().prompt();
+    });
+
+    // Inline handler: renders only messages from our current chat partner.
+    // Messages from others are already caught by the background handler above.
+    socket.on('receive_message', msg => {
+        if (msg.from !== recipient) return;
+        notify(msg.from, '…');
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        renderMsg(msg, myKeys.preKeyPriv, username);
+        getRL().prompt(true);
+    });
+
+    getRL().removeAllListeners('line');
+    getRL().setPrompt(`  ${c.bold(c.cyan('you'))} ${c.dim('›')} `);
+
+    getRL().on('line', async line => {
+        const text = line.trim();
+        if (!text) { getRL().prompt(); return; }
+
+        if (text === '/help') {
+            process.stdout.write(
+                `\n  ${c.bold('Commands')}\n\n` +
+                `  ${c.bold(c.cyan('/chat <name>'))}    switch to a DM with someone\n` +
+                `  ${c.bold(c.cyan('/chat @group'))}   switch to a group chat\n` +
+                `  ${c.bold(c.cyan('/who'))}           info about current recipient\n` +
+                `  ${c.bold(c.cyan('/status'))}        check if recipient is online\n` +
+                `  ${c.bold(c.cyan('/keys'))}          show key fingerprint\n` +
+                `  ${c.bold(c.cyan('/groups'))}        list your groups\n` +
+                `  ${c.bold(c.cyan('/inbox'))}         read unread from others\n` +
+                `  ${c.bold(c.cyan('/inbox <user>'))}  read unread from one person\n` +
+                `  ${c.bold(c.cyan('/ghost'))}         wipe all local data + exit\n` +
+                `  ${c.bold(c.cyan('/quit'))}          exit\n\n`
+            );
+            getRL().prompt(); return;
+        }
+        if (text === '/who') {
+            process.stdout.write(`  ${c.dim('Chatting with')} ${c.bold(c.green(recipient))} ${c.dim('on')} ${c.bold(serverAlias)}\n\n`);
+            getRL().prompt(); return;
+        }
+        if (text === '/status') {
+            try {
+                const { online } = await apiRequest(serverUrl, 'POST', '/online', { usernames: [recipient] }, token);
+                const dot = online.includes(recipient) ? c.brightGreen('● online') : c.dim('○ offline');
+                process.stdout.write(`  ${c.bold(c.green(recipient))} ${dot}\n\n`);
+            } catch (e) { process.stdout.write(`  ${c.brightRed('✖')}  ${e.message}\n\n`); }
+            getRL().prompt(); return;
+        }
+        if (text === '/keys') {
+            const fp = crypto.createHash('sha256').update(theirKeys.identityKey || '').digest('hex').slice(0, 16);
+            process.stdout.write(`  ${c.dim('Fingerprint')} ${c.yellow(fp.match(/.{4}/g).join(':'))}\n\n`);
+            getRL().prompt(); return;
+        }
+        if (text.startsWith('/chat ')) {
+            const target = text.slice(6).trim();
+            if (!target) { getRL().prompt(); return; }
+            socket.removeAllListeners('message_history');
+            socket.removeAllListeners('receive_message');
+            currentChat.type = null;
+            currentChat.with = null;
+            getRL().removeAllListeners('line');
+            const w = Math.min(process.stdout.columns || 72, 72);
+            process.stdout.write('\n' + c.dim('─'.repeat(w)) + '\n\n');
+            if (target.startsWith('@')) {
+                await runGroupChat(serverUrl, serverAlias, username, token, myKeys, socket, target.slice(1));
+            } else {
+                currentChat.type = 'dm';
+                currentChat.with = target;
+                const sw = spin(`Fetching ${target}'s keys…`);
+                try {
+                    theirKeys = await apiRequest(serverUrl, 'GET', `/keys/${target}`, null, token);
+                    keysCache.set(target, theirKeys.identityKey);
+                    sw.ok(`Switched to ${c.bold(c.green(target))}`);
+                } catch (e) { sw.fail(`Cannot switch: ${e.message}`); currentChat.type = null; getRL().prompt(); return; }
+                // Re-init inline without recursing — rebuild handlers
+                const newRecipient = target;
+                const newW = Math.min(process.stdout.columns || 72, 72);
+                process.stdout.write(c.dim('─'.repeat(newW)) + '\n');
+                process.stdout.write(
+                    `  ${c.bold(c.cyan(serverAlias))} ${c.dim('/')} ${c.bold(username)} ` +
+                    `${c.dim('→')} ${c.bold(c.green(newRecipient))} ` +
+                    `${c.bgGreen(c.bold(' E2EE '))}\n`
+                );
+                process.stdout.write(c.dim('  /chat <name|@group>  switch  · /who  · /keys  · /status  · /groups  · /inbox  · /help\n'));
+                process.stdout.write(c.dim('─'.repeat(newW)) + '\n\n');
+                socket.emit('fetch_messages');
+                socket.on('message_history', msgs2 => {
+                    if (msgs2.length) {
+                        process.stdout.write(c.dim(`  ── ${msgs2.length} queued ──\n`));
+                        for (const m of msgs2) renderMsg(m, myKeys.preKeyPriv, username);
+                        process.stdout.write(c.dim('  ─────────────\n\n'));
+                    }
+                    getRL().setPrompt(`  ${c.bold(c.cyan('you'))} ${c.dim('›')} `);
+                    getRL().prompt();
+                });
+                socket.on('receive_message', msg2 => {
+                    if (msg2.from !== newRecipient) return;
+                    notify(msg2.from, '…');
+                    readline.clearLine(process.stdout, 0);
+                    readline.cursorTo(process.stdout, 0);
+                    renderMsg(msg2, myKeys.preKeyPriv, username);
+                    getRL().prompt(true);
+                });
+            }
+            return;
+        }
+        if (text === '/groups') {
+            try {
+                const { groups: myGroups } = await apiRequest(serverUrl, 'GET', '/groups', null, token);
+                if (!myGroups.length) {
+                    process.stdout.write(c.dim('  No groups yet — chat with @groupname to create one.\n\n'));
+                } else {
+                    for (const g of myGroups)
+                        process.stdout.write(`  ${c.bold(c.cyan('@' + g.name))} ${c.dim('·')} ${g.memberCount} member${g.memberCount === 1 ? '' : 's'} ${g.owner === username ? c.dim('[owner]') : ''}\n`);
+                    process.stdout.write('\n');
+                }
+            } catch (e) { process.stdout.write(`  ${c.brightRed('✖')}  ${e.message}\n\n`); }
+            getRL().prompt(); return;
+        }
+        if (text === '/inbox' || text.startsWith('/inbox ')) {
+            const target  = text.startsWith('/inbox ') ? text.slice(7).trim() : null;
+            const dmKeys  = Object.keys(unreadBuf.dms);
+            const grpKeys = Object.keys(unreadBuf.groups);
+            if (!dmKeys.length && !grpKeys.length) {
+                process.stdout.write(c.dim('  No unread messages.\n\n'));
+                getRL().prompt(); return;
+            }
+            if (target) {
+                const msgs = unreadBuf.dms[target] || [];
+                if (!msgs.length) { process.stdout.write(c.dim(`  No unread from ${target}.\n\n`)); getRL().prompt(); return; }
+                process.stdout.write(c.dim(`  ── from ${target} ──\n`));
+                for (const m of msgs) renderMsg(m, myKeys.preKeyPriv, username);
+                process.stdout.write(c.dim('  ─────────────\n\n'));
+                delete unreadBuf.dms[target];
+            } else {
+                for (const sender of dmKeys) {
+                    process.stdout.write(c.dim(`  ── DM from ${sender} ──\n`));
+                    for (const m of unreadBuf.dms[sender]) renderMsg(m, myKeys.preKeyPriv, username);
+                    process.stdout.write(c.dim('  ─────────────\n\n'));
+                }
+                unreadBuf.dms = {};
+                for (const gn of grpKeys) {
+                    const n = unreadBuf.groups[gn].length;
+                    process.stdout.write(c.dim(`  ── @${gn}: ${n} message${n === 1 ? '' : 's'} — switch to @${gn} to read ──\n\n`));
+                }
+            }
+            getRL().prompt(); return;
+        }
+        if (text === '/quit') {
+            socket.disconnect(); getRL().close();
+            process.stdout.write(c.dim('\n  Disconnected.\n\n'));
+            process.exit(0);
+        }
+        if (text === '/ghost') {
+            socket.disconnect(); getRL().close();
+            process.stdout.write(`\n  ${c.bgRed(c.bold('  GHOST MODE  '))}  Wiping all local data…\n`);
+            try { fs.rmSync(CONFIG_DIR, { recursive: true, force: true }); } catch {}
+            process.stdout.write(c.dim('  Erased. Goodbye.\n\n'));
+            process.exit(0);
+        }
+
+        if (text.startsWith('/')) {
+            process.stdout.write(c.dim(`  Unknown command. Type /help for a list.\n\n`));
+            getRL().prompt(); return;
+        }
+
+        try {
+            const eph = crypto.generateKeyPairSync('x25519', {
+                publicKeyEncoding:  { type: 'spki',  format: 'der' },
+                privateKeyEncoding: { type: 'pkcs8', format: 'der' },
+            });
+            const ratchetKey  = eph.publicKey.toString('base64');
+            const ratchetPriv = eph.privateKey.toString('base64');
+            const aesKey      = ecdhKey(ratchetPriv, theirKeys.preKey);
+            const timestamp   = Date.now();
+            const aad         = `zypher-dm:${username}:${recipient}`;
+            const { ciphertext, nonce } = encryptMsg(text, aesKey, aad);
+            const sigData     = `${ciphertext}|${nonce}|${ratchetKey}|${recipient}|${timestamp}`;
+            const signature   = signMsg(sigData, myKeys.identityPrivKey);
+            socket.emit('send_message', { to: recipient, ciphertext, nonce, ratchetKey, timestamp, signature });
+            // Overwrite the raw input line with the formatted message display.
+            // Use readline's own cursor APIs — raw ANSI codes conflict with
+            // readline's internal terminal state on Windows.
+            if (TTY) {
+                readline.moveCursor(process.stdout, 0, -1); // move up one line
+                readline.clearLine(process.stdout, 0);       // erase it
+                readline.cursorTo(process.stdout, 0);        // go to column 0
+            }
+            process.stdout.write(`  ${c.bold(c.cyan('you'))} ${c.gray(ts())}  ${text}\n`);
+        } catch (err) {
+            process.stdout.write(`  ${c.brightRed('✖')}  Encrypt error: ${err.message}\n`);
+        }
+        getRL().prompt();
+    });
+}
+
+function renderMsg(msg, privB64, self) {
+    const time = ts(msg.timestamp);
+    const isSelf = msg.from === self;
+    try {
+        const key    = ecdhKey(privB64, msg.ratchetKey);
+        const aad    = `zypher-dm:${msg.from}:${self}`;
+        const text   = decryptMsg(msg.ciphertext, msg.nonce, key, aad);
+        // Verify Ed25519 signature if sender's identity key is cached
+        let sigMark = '';
+        const senderPub = keysCache.get(msg.from);
+        if (senderPub && msg.signature) {
+            const sigData = `${msg.ciphertext}|${msg.nonce}|${msg.ratchetKey}|${self}|${msg.timestamp}`;
+            sigMark = verifyMsg(sigData, msg.signature, senderPub) ? c.dim(' ✓') : c.brightRed(' ⚠ TAMPERED');
+        }
+        const name = isSelf ? c.bold(c.cyan(msg.from)) : c.bold(c.green(msg.from));
+        process.stdout.write(`  ${name}${sigMark} ${c.gray(time)}  ${text}\n`);
+    } catch {
+        process.stdout.write(`  ${c.bold(c.green(msg.from))} ${c.gray(time)}  ${c.dim('<unable to decrypt>')}\n`);
+    }
+}
+
+function renderGroupMsg(msg, groupKey, self) {
+    const time = ts(msg.timestamp);
+    try {
+        const buf    = Buffer.from(msg.ciphertext, 'base64');
+        const nonce  = Buffer.from(msg.nonce,       'base64');
+        const tag    = buf.slice(buf.length - 16);
+        const enc    = buf.slice(0, buf.length - 16);
+        const aad    = `zypher-group:${msg.from}:${msg.groupName}`;
+        const d      = crypto.createDecipheriv('aes-256-gcm', groupKey, nonce);
+        d.setAAD(Buffer.from(aad));
+        d.setAuthTag(tag);
+        const text   = Buffer.concat([d.update(enc), d.final()]).toString('utf8');
+        // Verify Ed25519 signature if sender's identity key is cached
+        let sigMark = '';
+        const senderPub = keysCache.get(msg.from);
+        if (senderPub && msg.signature) {
+            const sigData = `${msg.ciphertext}|${msg.nonce}|${msg.groupName}|${msg.timestamp}`;
+            sigMark = verifyMsg(sigData, msg.signature, senderPub) ? c.dim(' ✓') : c.brightRed(' ⚠ TAMPERED');
+        }
+        const name   = msg.from === self ? c.bold(c.cyan(msg.from)) : c.bold(c.magenta(msg.from));
+        process.stdout.write(`  ${name}${sigMark} ${c.gray(time)}  ${text}\n`);
+    } catch {
+        process.stdout.write(`  ${c.bold(c.magenta(msg.from))} ${c.gray(time)}  ${c.dim('<unable to decrypt>')}\n`);
+    }
+}
+
+async function runGroupChat(serverUrl, serverAlias, username, token, myKeys, socket, groupName) {
+    // ── Resolve / create group ────────────────────────────────────────────────
+    let groupInfo;
+    {
+        const s = spin(`Connecting to @${groupName}…`);
+        try {
+            groupInfo = await apiRequest(serverUrl, 'GET', `/groups/${encodeURIComponent(groupName)}`, null, token);
+            s.ok(`Group @${groupName} · ${groupInfo.members.length} member${groupInfo.members.length === 1 ? '' : 's'}`);
+            // Prefetch identity keys for all members so signatures can be verified
+            await Promise.allSettled(groupInfo.members
+                .filter(m => !keysCache.has(m))
+                .map(async m => {
+                    try { const k = await apiRequest(serverUrl, 'GET', `/keys/${m}`, null, token); keysCache.set(m, k.identityKey); } catch {}
+                })
+            );
+        } catch (err) {
+            if (/not found|404/i.test(err.message)) {
+                s.stop();
+                process.stdout.write(`\n  ${c.yellow('!')}  Group @${c.bold(groupName)} does not exist.\n`);
+                const ans = (await ask('  Create it? [y/N] : ')).trim().toLowerCase();
+                if (ans !== 'y') { socket.disconnect(); return; }
+                const cs = spin(`Creating @${groupName}…`);
+                try {
+                    await apiRequest(serverUrl, 'POST', '/groups', { name: groupName }, token);
+                    cs.ok(`Created @${groupName}`);
+                    groupInfo = { name: groupName, owner: username, members: [username] };
+                } catch (e) { cs.fail(`Failed: ${e.message}`); socket.disconnect(); return; }
+            } else {
+                s.fail(`Cannot access group: ${err.message}`);
+                socket.disconnect(); return;
+            }
+        }
+    }
+
+    // ── Resolve group key ─────────────────────────────────────────────────────
+    let groupKey;
+    {
+        const s = spin('Loading group key…');
+        try {
+            const bundle = await apiRequest(serverUrl, 'GET', `/groups/${encodeURIComponent(groupName)}/key_bundle`, null, token);
+            groupKey = decryptGroupKey(bundle, myKeys.preKeyPriv);
+            s.ok('Group key ready');
+        } catch (err) {
+            if (/No key bundle/i.test(err.message)) {
+                groupKey = crypto.randomBytes(32);
+                s.update('Generating group key…');
+                const myBundle = { username, ...encryptGroupKeyForUser(groupKey, myKeys.preKeyPub) };
+                try {
+                    await apiRequest(serverUrl, 'POST', `/groups/${encodeURIComponent(groupName)}/key_bundle`, { bundles: [myBundle] }, token);
+                    s.ok('Group key generated');
+                } catch (e) { s.fail(`Cannot store key: ${e.message}`); socket.disconnect(); return; }
+            } else {
+                s.fail(`Cannot load group key: ${err.message}`);
+                socket.disconnect(); return;
+            }
+        }
+    }
+
+    // ── Header + fetch offline queue ──────────────────────────────────────────
+    currentChat.type = 'group';
+    currentChat.with = groupName;
+
+    const initGroup = () => {
+        socket.emit('fetch_group_messages', { groupName });
+        const w = Math.min(process.stdout.columns || 72, 72);
+        process.stdout.write('\n' + c.dim('─'.repeat(w)) + '\n');
+        process.stdout.write(
+            `  ${c.bold(c.cyan(serverAlias))} ${c.dim('/')} ${c.bold(username)} ` +
+            `${c.dim('→')} ${c.bold(c.magenta('@' + groupName))} ` +
+            `${c.bgGreen(c.bold(' E2EE GROUP '))} ${c.dim('·')} ${c.dim(groupInfo.members.length + ' member' + (groupInfo.members.length === 1 ? '' : 's'))}\n`
+        );
+        process.stdout.write(
+            c.dim('  /chat <name|@group>  switch  · /members  · /status  · /invite  · /inbox  · /help\n')
+        );
+        process.stdout.write(c.dim('─'.repeat(w)) + '\n\n');
+    };
+    if (socket.connected) initGroup();
+    else socket.once('connect', initGroup);
+
+    socket.on('group_message_history', ({ groupName: gn, msgs }) => {
+        if (gn !== groupName) return;
+        if (msgs.length) {
+            process.stdout.write(c.dim(`  ── ${msgs.length} queued ──\n`));
+            for (const m of msgs) renderGroupMsg(m, groupKey, username);
+            process.stdout.write(c.dim('  ─────────────\n\n'));
+        }
+        // Show cross-chat unread summary collected before we entered this group
+        const dmTotal  = Object.values(unreadBuf.dms).reduce((s, a) => s + a.length, 0);
+        const grpTotal = Object.values(unreadBuf.groups).filter(k => k !== groupName).reduce((s, a) => s + a.length, 0);
+        if (dmTotal || grpTotal) {
+            const parts = [];
+            if (dmTotal)  parts.push(`${dmTotal} unread DM${dmTotal  === 1 ? '' : 's'} from ${Object.keys(unreadBuf.dms).join(', ')}`);
+            if (grpTotal) parts.push(`${grpTotal} group msg${grpTotal === 1 ? '' : 's'} in ${Object.keys(unreadBuf.groups).filter(g => g !== groupName).map(g => '@' + g).join(', ')}`);
+            process.stdout.write(`  ${c.bgYellow(c.bold(' UNREAD '))} ${c.dim(parts.join(' · '))} ${c.dim('· /inbox to read')}\n\n`);
+        }
+        getRL().setPrompt(`  ${c.bold(c.magenta('@' + groupName))} ${c.dim('›')} `);
+        getRL().prompt();
+    });
+
+    socket.on('receive_group_message', msg => {
+        if (msg.groupName !== groupName) return;
+        if (msg.from !== username) notify(msg.from, `[group @${groupName}]`);
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        renderGroupMsg(msg, groupKey, username);
+        getRL().prompt(true);
+    });
+
+    getRL().removeAllListeners('line');
+    getRL().setPrompt(`  ${c.bold(c.magenta('@' + groupName))} ${c.dim('›')} `);
+
+    getRL().on('line', async line => {
+        const text = line.trim();
+        if (!text) { getRL().prompt(); return; }
+
+        if (text === '/help') {
+            process.stdout.write(
+                `\n  ${c.bold('Commands')}\n\n` +
+                `  ${c.bold(c.magenta('/chat <name>'))}    switch to a DM\n` +
+                `  ${c.bold(c.magenta('/chat @group'))}   switch to another group\n` +
+                `  ${c.bold(c.magenta('/members'))}       list members + online status\n` +
+                `  ${c.bold(c.magenta('/status'))}        show group online count\n` +
+                `  ${c.bold(c.magenta('/invite <user>'))} invite someone\n` +
+                `  ${c.bold(c.magenta('/inbox'))}         read unread from other chats\n` +
+                `  ${c.bold(c.magenta('/ghost'))}         wipe all local data + exit\n` +
+                `  ${c.bold(c.magenta('/quit'))}          exit\n\n`
+            );
+            getRL().prompt(); return;
+        }
+
+        if (text === '/members') {
+            try {
+                const info    = await apiRequest(serverUrl, 'GET', `/groups/${encodeURIComponent(groupName)}`, null, token);
+                const { online } = await apiRequest(serverUrl, 'POST', '/online', { usernames: info.members }, token);
+                const onlineSet = new Set(online);
+                const w = Math.min(process.stdout.columns || 72, 72);
+                process.stdout.write(c.dim(`  ── @${groupName} members ──\n`));
+                for (const m of info.members) {
+                    const dot  = onlineSet.has(m) ? c.brightGreen('●') : c.dim('○');
+                    const name = m === username ? c.bold(c.cyan(m + ' (you)')) : c.bold(c.green(m));
+                    const own  = m === info.owner ? c.dim(' [owner]') : '';
+                    process.stdout.write(`  ${dot}  ${name}${own}\n`);
+                }
+                process.stdout.write('\n');
+            } catch (e) { process.stdout.write(`  ${c.brightRed('✖')}  ${e.message}\n\n`); }
+            getRL().prompt(); return;
+        }
+
+        if (text === '/status') {
+            try {
+                const info       = await apiRequest(serverUrl, 'GET', `/groups/${encodeURIComponent(groupName)}`, null, token);
+                const { online } = await apiRequest(serverUrl, 'POST', '/online', { usernames: info.members }, token);
+                const onlineSet  = new Set(online);
+                process.stdout.write(`  ${c.bold(c.magenta('@' + groupName))} members:\n`);
+                for (const m of info.members) {
+                    const dot = onlineSet.has(m) ? c.brightGreen('●') : c.dim('○');
+                    const tag = m === info.owner ? c.dim(' [owner]') : '';
+                    const you = m === username   ? c.dim(' (you)')   : '';
+                    process.stdout.write(`    ${dot} ${c.bold(m)}${tag}${you}\n`);
+                }
+                process.stdout.write('\n');
+            } catch (e) { process.stdout.write(`  ${c.brightRed('✖')}  ${e.message}\n\n`); }
+            getRL().prompt(); return;
+        }
+
+        if (text.startsWith('/invite ') || text === '/invite') {
+            const invitee = text.slice(8).trim();
+            if (!invitee) { process.stdout.write(c.dim('  Usage: /invite <username>\n\n')); getRL().prompt(); return; }
+            const si = spin(`Inviting ${c.bold(invitee)}…`);
+            try {
+                const theirKeys = await apiRequest(serverUrl, 'GET', `/keys/${invitee}`, null, token);
+                await apiRequest(serverUrl, 'POST', `/groups/${encodeURIComponent(groupName)}/invite`, { username: invitee }, token);
+                const bundle = { username: invitee, ...encryptGroupKeyForUser(groupKey, theirKeys.preKey) };
+                await apiRequest(serverUrl, 'POST', `/groups/${encodeURIComponent(groupName)}/key_bundle`, { bundles: [bundle] }, token);
+                si.ok(`${c.bold(invitee)} invited to @${groupName}`);
+            } catch (e) { si.fail(`Invite failed: ${e.message}`); }
+            getRL().prompt(); return;
+        }
+
+        if (text.startsWith('/chat ')) {
+            const target = text.slice(6).trim();
+            if (!target) { getRL().prompt(); return; }
+            socket.removeAllListeners('group_message_history');
+            socket.removeAllListeners('receive_group_message');
+            currentChat.type = null;
+            currentChat.with = null;
+            getRL().removeAllListeners('line');
+            const w = Math.min(process.stdout.columns || 72, 72);
+            process.stdout.write('\n' + c.dim('─'.repeat(w)) + '\n\n');
+            if (target.startsWith('@')) {
+                await runGroupChat(serverUrl, serverAlias, username, token, myKeys, socket, target.slice(1));
+            } else {
+                // Switch to a 1:1, re-enter runGroupChat's parent (runChat) is not possible,
+                // so inline-construct a minimal 1:1 session.
+                currentChat.type = 'dm';
+                currentChat.with = target;
+                const sw = spin(`Fetching ${target}'s keys…`);
+                let targetKeys;
+                try {
+                    targetKeys = await apiRequest(serverUrl, 'GET', `/keys/${target}`, null, token);
+                    keysCache.set(target, targetKeys.identityKey);
+                    sw.ok(`Switched to ${c.bold(c.green(target))}`);
+                } catch (e) { sw.fail(`Cannot switch: ${e.message}`); currentChat.type = null; getRL().prompt(); return; }
+                const newW = Math.min(process.stdout.columns || 72, 72);
+                process.stdout.write(c.dim('─'.repeat(newW)) + '\n');
+                process.stdout.write(
+                    `  ${c.bold(c.cyan(serverAlias))} ${c.dim('/')} ${c.bold(username)} ` +
+                    `${c.dim('→')} ${c.bold(c.green(target))} ` +
+                    `${c.bgGreen(c.bold(' E2EE '))}\n`
+                );
+                process.stdout.write(c.dim('  /chat <name|@group>  switch  · /who  · /keys  · /status  · /groups  · /inbox  · /help\n'));
+                process.stdout.write(c.dim('─'.repeat(newW)) + '\n\n');
+                socket.emit('fetch_messages');
+                socket.on('message_history', msgs2 => {
+                    if (msgs2.length) {
+                        process.stdout.write(c.dim(`  ── ${msgs2.length} queued ──\n`));
+                        for (const m of msgs2) renderMsg(m, myKeys.preKeyPriv, username);
+                        process.stdout.write(c.dim('  ─────────────\n\n'));
+                    }
+                    getRL().setPrompt(`  ${c.bold(c.cyan('you'))} ${c.dim('›')} `);
+                    getRL().prompt();
+                });
+                socket.on('receive_message', msg2 => {
+                    if (msg2.from !== target) return;
+                    notify(msg2.from, '…');
+                    readline.clearLine(process.stdout, 0);
+                    readline.cursorTo(process.stdout, 0);
+                    renderMsg(msg2, myKeys.preKeyPriv, username);
+                    getRL().prompt(true);
+                });
+                getRL().removeAllListeners('line');
+                getRL().setPrompt(`  ${c.bold(c.cyan('you'))} ${c.dim('›')} `);
+                getRL().on('line', async line2 => {
+                    const t2 = line2.trim();
+                    if (!t2) { getRL().prompt(); return; }
+                    if (t2 === '/quit') { socket.disconnect(); getRL().close(); process.stdout.write(c.dim('\n  Disconnected.\n\n')); process.exit(0); }
+                    if (t2 === '/ghost') { socket.disconnect(); getRL().close(); try { fs.rmSync(CONFIG_DIR, { recursive: true, force: true }); } catch {} process.stdout.write(c.dim('  Erased.\n\n')); process.exit(0); }
+                    if (t2 === '/who') { process.stdout.write(`  ${c.dim('Chatting with')} ${c.bold(c.green(target))}\n\n`); getRL().prompt(); return; }
+                    if (t2 === '/status') {
+                        try { const { online } = await apiRequest(serverUrl, 'POST', '/online', { usernames: [target] }, token); process.stdout.write(`  ${c.bold(c.green(target))} ${online.includes(target) ? c.brightGreen('● online') : c.dim('○ offline')}\n\n`); } catch (e) { process.stdout.write(`  ${c.brightRed('✖')}  ${e.message}\n\n`); }
+                        getRL().prompt(); return;
+                    }
+                    if (t2.startsWith('/chat ')) {
+                        const t3 = t2.slice(6).trim();
+                        if (!t3) { getRL().prompt(); return; }
+                        socket.removeAllListeners('message_history'); socket.removeAllListeners('receive_message');
+                        currentChat.type = null; currentChat.with = null; getRL().removeAllListeners('line');
+                        process.stdout.write('\n' + c.dim('─'.repeat(Math.min(process.stdout.columns||72,72))) + '\n\n');
+                        if (t3.startsWith('@')) { await runGroupChat(serverUrl, serverAlias, username, token, myKeys, socket, t3.slice(1)); }
+                        else { currentChat.type='dm'; currentChat.with=t3; /* minimal re-init not repeated here */ getRL().prompt(); }
+                        return;
+                    }
+                    try {
+                        const eph2 = crypto.generateKeyPairSync('x25519', { publicKeyEncoding: { type:'spki', format:'der' }, privateKeyEncoding: { type:'pkcs8', format:'der' } });
+                        const rk2 = eph2.publicKey.toString('base64'), rp2 = eph2.privateKey.toString('base64');
+                        const ak2 = ecdhKey(rp2, targetKeys.preKey);
+                        const ts2  = Date.now();
+                        const aad2 = `zypher-dm:${username}:${target}`;
+                        const { ciphertext: ct2, nonce: n2 } = encryptMsg(t2, ak2, aad2);
+                        const sig2 = signMsg(`${ct2}|${n2}|${rk2}|${target}|${ts2}`, myKeys.identityPrivKey);
+                        socket.emit('send_message', { to: target, ciphertext: ct2, nonce: n2, ratchetKey: rk2, timestamp: ts2, signature: sig2 });
+                        if (TTY) { readline.moveCursor(process.stdout,0,-1); readline.clearLine(process.stdout,0); readline.cursorTo(process.stdout,0); }
+                        process.stdout.write(`  ${c.bold(c.cyan('you'))} ${c.gray(ts())}  ${t2}\n`);
+                    } catch (err) { process.stdout.write(`  ${c.brightRed('✖')}  ${err.message}\n`); }
+                    getRL().prompt();
+                });
+            }
+            return;
+        }
+
+        if (text === '/inbox') {
+            const dmKeys  = Object.keys(unreadBuf.dms);
+            const grpKeys = Object.keys(unreadBuf.groups).filter(g => g !== groupName);
+            if (!dmKeys.length && !grpKeys.length) {
+                process.stdout.write(c.dim('  No unread messages.\n\n'));
+                getRL().prompt(); return;
+            }
+            for (const sender of dmKeys) {
+                process.stdout.write(c.dim(`  ── DM from ${sender} ──\n`));
+                for (const m of unreadBuf.dms[sender]) renderMsg(m, myKeys.preKeyPriv, username);
+                process.stdout.write(c.dim('  ─────────────\n\n'));
+            }
+            unreadBuf.dms = {};
+            for (const gn of grpKeys) {
+                const n = unreadBuf.groups[gn].length;
+                process.stdout.write(c.dim(`  ── @${gn}: ${n} message${n === 1 ? '' : 's'} — switch to @${gn} to read ──\n\n`));
+            }
+            getRL().prompt(); return;
+        }
+        if (text === '/quit') {
+            socket.disconnect(); getRL().close();
+            process.stdout.write(c.dim('\n  Disconnected.\n\n'));
+            process.exit(0);
+        }
+        if (text === '/ghost') {
+            socket.disconnect(); getRL().close();
+            process.stdout.write(`\n  ${c.bgRed(c.bold('  GHOST MODE  '))}  Wiping all local data…\n`);
+            try { fs.rmSync(CONFIG_DIR, { recursive: true, force: true }); } catch {}
+            process.stdout.write(c.dim('  Erased. Goodbye.\n\n'));
+            process.exit(0);
+        }
+
+        if (text.startsWith('/')) {
+            process.stdout.write(c.dim(`  Unknown command. Type /help for a list.\n\n`));
+            getRL().prompt(); return;
+        }
+
+        // Encrypt with the shared group key (AES-256-GCM, unique nonce per message)
+        try {
+            const nonce      = crypto.randomBytes(12);
+            const timestamp  = Date.now();
+            const aad        = `zypher-group:${username}:${groupName}`;
+            const cipher     = crypto.createCipheriv('aes-256-gcm', groupKey, nonce);
+            cipher.setAAD(Buffer.from(aad));
+            const enc        = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+            const tag        = cipher.getAuthTag();
+            const ciphertext = Buffer.concat([enc, tag]).toString('base64');
+            const nonceB64   = nonce.toString('base64');
+            const sigData    = `${ciphertext}|${nonceB64}|${groupName}|${timestamp}`;
+            const signature  = signMsg(sigData, myKeys.identityPrivKey);
+            socket.emit('send_group_message', { groupName, ciphertext, nonce: nonceB64, timestamp, signature });
+            if (TTY) {
+                readline.moveCursor(process.stdout, 0, -1);
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+            }
+            process.stdout.write(`  ${c.bold(c.cyan('you'))} ${c.gray(ts())}  ${text}\n`);
+        } catch (err) {
+            process.stdout.write(`  ${c.brightRed('✖')}  Encrypt error: ${err.message}\n`);
+        }
+        getRL().prompt();
+    });
+}
+
+function ts(ms) {
+    return new Date(ms || Date.now()).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+}
+
+// ── zypher settings ───────────────────────────────────────────────────────────
+function getDaemonPid() {
+    try {
+        const pid = parseInt(fs.readFileSync(SERVER_PID, 'utf8').trim(), 10);
+        process.kill(pid, 0); return pid;
+    } catch { return null; }
+}
+
+async function cmdSettings() {
+    while (true) {
+        printBanner();
+        const cfg        = loadConfig();
+        const serverList = Object.keys(cfg.servers || {});
+        const pid        = getDaemonPid();
+
+        process.stdout.write(rule('settings') + '\n\n');
+
+        // Servers table
+        process.stdout.write(`  ${c.bold('Servers')}\n\n`);
+        if (!serverList.length) {
+            process.stdout.write(c.dim('    none\n'));
+        } else {
+            for (const alias of serverList) {
+                const srv   = cfg.servers[alias];
+                const count = Object.keys(cfg.accounts?.[alias] || {}).length;
+                process.stdout.write(
+                    `    ${c.bold(c.cyan(alias.padEnd(16)))}  ${c.gray(srv.url.padEnd(32))}  ` +
+                    `${c.dim(count + ' acct' + (count !== 1 ? 's' : ''))}\n`
+                );
+            }
+        }
+        process.stdout.write('\n');
+        process.stdout.write(`  ${c.dim('Local daemon')}  ${pid ? badge('running') + c.dim(` PID ${pid}`) : badge('stopped')}\n`);
+        process.stdout.write('\n' + rule('options') + '\n\n');
+
+        const opts = [
+            ['1', 'Add / connect to new server'],
+            ['2', 'Rename server'],
+            ['3', 'Remove server'],
+            ['4', 'List accounts'],
+            ['5', 'Remove account'],
+            ['6', 'Daemon status'],
+            ['7', c.red('GHOST — erase ALL local data')],
+            ['8', 'Back / Quit'],
+        ];
+        for (const [k, label] of opts)
+            process.stdout.write(`  ${c.bold(c.cyan(k))}  ${label}\n`);
+        process.stdout.write('\n');
+
+        const choice = (await ask(`  ${c.dim('›')} `)).trim();
+        process.stdout.write('\n');
+
+        if (choice === '1') {
+            getRL().close(); rl = null;
+            await cmdNew();
+            rl = null;
+
+        } else if (choice === '2') {
+            const old = (await ask(`  ${c.bold('Current alias')} : `)).trim();
+            if (!cfg.servers[old]) { process.stdout.write('  Not found.\n\n'); continue; }
+            const nxt = (await ask(`  ${c.bold('New alias')}     : `)).trim();
+            if (!nxt) { process.stdout.write('  Cannot be empty.\n\n'); continue; }
+            cfg.servers[nxt] = { ...cfg.servers[old], alias: nxt };
+            delete cfg.servers[old];
+            if (cfg.accounts[old]) { cfg.accounts[nxt] = cfg.accounts[old]; delete cfg.accounts[old]; }
+            saveConfig(cfg);
+            process.stdout.write(`  ${c.brightGreen('✔')}  Renamed "${old}" → "${nxt}"\n\n`);
+
+        } else if (choice === '3') {
+            const alias = (await ask(`  ${c.bold('Alias to remove')} : `)).trim();
+            if (!cfg.servers[alias]) { process.stdout.write('  Not found.\n\n'); continue; }
+            delete cfg.servers[alias]; delete cfg.accounts[alias];
+            saveConfig(cfg);
+            process.stdout.write(`  ${c.brightGreen('✔')}  Removed "${alias}"\n\n`);
+
+        } else if (choice === '4') {
+            const entries = [];
+            for (const srv of Object.keys(cfg.accounts || {}))
+                for (const u of Object.keys(cfg.accounts[srv]))
+                    entries.push(`  ${c.bold(c.cyan(srv))} ${c.dim('/')} ${u}`);
+            process.stdout.write(entries.length ? entries.join('\n') + '\n\n' : c.dim('  No accounts stored.\n\n'));
+
+        } else if (choice === '5') {
+            const srv = (await ask(`  ${c.bold('Server alias')} : `)).trim();
+            const usr = (await ask(`  ${c.bold('Username')}     : `)).trim();
+            if (cfg.accounts?.[srv]?.[usr]) {
+                delete cfg.accounts[srv][usr]; saveConfig(cfg);
+                process.stdout.write(`  ${c.brightGreen('✔')}  Removed "${usr}" from "${srv}"\n\n`);
+            } else {
+                process.stdout.write('  Not found.\n\n');
+            }
+
+        } else if (choice === '6') {
+            cmdServerStatus();
+
+        } else if (choice === '7') {
+            process.stdout.write(`  ${c.bgRed(c.bold('  !! GHOST MODE !!  '))}  This erases everything.\n\n`);
+            const confirm = (await ask(`  Type ${c.bold('GHOST')} to confirm: `)).trim();
+            if (confirm === 'GHOST') {
+                try { fs.rmSync(CONFIG_DIR, { recursive: true, force: true }); } catch {}
+                process.stdout.write(`\n  ${c.brightGreen('✔')}  All local data erased.\n\n`);
+                getRL().close(); process.exit(0);
+            } else {
+                process.stdout.write('  Cancelled.\n\n');
+            }
+
+        } else {
+            getRL().close(); break;
+        }
+    }
+}
+
+// ── Entry point ───────────────────────────────────────────────────────────────
+async function main() {
+    const [,, cmd, sub] = process.argv;
+    try {
+        if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') { printHelp(); process.exit(0); }
+
+        if (cmd === 'server') {
+            if (sub === 'quickstart') { await cmdServerQuickstart(); return; }
+            if (sub === 'stop')       { cmdServerStop();             return; }
+            if (sub === 'status')     { cmdServerStatus();           return; }
+            process.stdout.write(`\n  ${c.brightRed('✖')}  Unknown server subcommand "${sub}".\n\n`);
+            printHelp(); process.exit(1);
+        }
+
+        if (cmd === 'new')      { await cmdNew();      return; }
+        if (cmd === 'settings') { await cmdSettings(); return; }
+
+        await cmdConnect(cmd, sub);
+    } catch (err) {
+        process.stdout.write(`\n  ${c.brightRed('✖')}  ${err.message || err}\n\n`);
+        if (rl) { try { rl.close(); } catch {} }
+        process.exit(1);
+    }
+}
+
+main();