ldrouter 1.6.0 → 1.6.2

package/dist/server/cli/tui/noise.js

@@ -0,0 +1,397 @@
+/**
+ * Zero-dependency interactive console UI for ldrouter.
+ *
+ * Raw stdin + ANSI escape codes only — no external dependencies. Boots the
+ * real server (DB -> Fastify listen), then drives a menu:
+ *   Open Dashboard / Check for Updates / Exit.
+ */
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+import { hideCursor, showCursor, home, eraseDown, color } from './ansi.js';
+import { getAppVersion } from '../../version.js';
+import { loadConfig } from '../../config/index.js';
+import { buildApp } from '../../app.js';
+import { closeDb } from '../../db/index.js';
+import { getSelfUpdater } from '../../selfupdate/index.js';
+// Key sequences as escape literals (never raw control bytes in source).
+const KEY = {
+    up: '\x1B[A', // ESC [ A
+    down: '\x1B[B', // ESC [ B
+    enter: '\r',
+    newline: '\n',
+    space: ' ',
+    ctrlC: '\x03', // Ctrl+C
+    esc: '\x1B', // Escape key
+};
+const WIDTH = 36;
+const PAD = 2;
+let cfg;
+let app = null;
+let startedAt = Date.now();
+let screen = { name: 'menu' };
+let menuSel = 0;
+let lastRender = '';
+// ---------------------------------------------------------------- output
+function out(s) {
+    process.stdout.write(s);
+}
+function fmtUptime(ms) {
+    const s = Math.floor(ms / 1000);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${pad(Math.floor(s / 3600))}:${pad(Math.floor((s % 3600) / 60))}:${pad(s % 60)}`;
+}
+function kv(label, value) {
+    return `${' '.repeat(PAD)}${color.gray}${label.padEnd(12)}${color.reset}${value}`;
+}
+function menuItem(label, selected) {
+    const marker = selected ? `${color.cyan}❯ ${color.reset}` : '  ';
+    const text = selected ? `${color.cyan}${label}${color.reset}` : label;
+    return `${' '.repeat(PAD)}${marker}${text}`;
+}
+function header() {
+    return [
+        `${color.cyan}${color.bold}LateDev Router${color.reset}`,
+        `${color.gray}${'─'.repeat(WIDTH)}${color.reset}`,
+        '',
+    ];
+}
+function footer() {
+    return `${' '.repeat(PAD)}${color.gray}↑↓ Navigate    Enter Select    q Exit${color.reset}`;
+}
+function spinnerFrame(tick) {
+    const frames = ['◐', '◓', '◑', '◒'];
+    return frames[Math.floor(tick / 2) % frames.length];
+}
+function renderMenu() {
+    const url = `http://localhost:${cfg.port}`;
+    const items = ['Open Dashboard', 'Check for Updates', 'Exit'];
+    return [
+        ...header(),
+        `${color.green}● Server is running${color.reset}`,
+        '',
+        kv('Dashboard', url),
+        kv('Version', `v${getAppVersion()}`),
+        kv('Uptime', fmtUptime(Date.now() - startedAt)),
+        '',
+        ...items.map((label, i) => menuItem(label, i === menuSel)),
+        '',
+        footer(),
+    ].join('\n');
+}
+function renderCheck(tick) {
+    return [
+        ...header(),
+        `${spinnerFrame(tick)} Checking for updates...`,
+    ].join('\n');
+}
+function renderCheckResult(r, sel) {
+    const lines = [...header()];
+    if (r.latestVersion === null) {
+        lines.push(`${color.red}✗ Could not reach the update server${color.reset}`, '', kv('Version', `v${r.currentVersion}`), '', menuItem('Back', sel === 0));
+    }
+    else if (r.hasUpdate) {
+        lines.push(kv('Current', `v${r.currentVersion}`), kv('Latest', `v${r.latestVersion}`), '', `${color.green}New version available.${color.reset}`, '', menuItem(`Update to v${r.latestVersion}`, sel === 0), menuItem('Back', sel === 1));
+    }
+    else {
+        lines.push(`${color.green}✓ You're up to date${color.reset}`, '', kv('Version', `v${r.currentVersion}`), '', menuItem('Back', sel === 0));
+    }
+    lines.push('', footer());
+    return lines.join('\n');
+}
+function renderApplying(tick, to) {
+    return [
+        ...header(),
+        `${spinnerFrame(tick)} Updating to v${to}...`,
+        '',
+        `${' '.repeat(PAD)}${color.gray}Installing the new version with your package manager.${color.reset}`,
+        `${' '.repeat(PAD)}${color.gray}The gateway restarts automatically.${color.reset}`,
+    ].join('\n');
+}
+function renderUpdated(from, to, sel) {
+    return [
+        ...header(),
+        `${color.green}✓ LDRouter updated successfully${color.reset}`,
+        '',
+        `${' '.repeat(PAD)}v${from} → v${to}`,
+        '',
+        menuItem('Restart', sel === 0),
+        menuItem('Exit', sel === 1),
+        '',
+        footer(),
+    ].join('\n');
+}
+function renderMessage(title, lines, ok) {
+    return [
+        ...header(),
+        `${ok ? color.green + '✓' : color.red + '✗'} ${title}${color.reset}`,
+        ...lines.map((l) => `${' '.repeat(PAD)}${color.gray}${l}${color.reset}`),
+        '',
+        menuItem('Back', true),
+        '',
+        footer(),
+    ].join('\n');
+}
+function draw() {
+    let body;
+    const s = screen;
+    if (s.name === 'menu')
+        body = renderMenu();
+    else if (s.name === 'check')
+        body = renderCheck(s.spinner);
+    else if (s.name === 'checkResult')
+        body = renderCheckResult(s.result, s.sel);
+    else if (s.name === 'applying')
+        body = renderApplying(s.spinner, s.to);
+    else if (s.name === 'updated')
+        body = renderUpdated(s.from, s.to, s.sel);
+    else
+        body = renderMessage(s.title, s.lines, s.ok);
+    if (body === lastRender)
+        return;
+    lastRender = body;
+    out(home + body + '\n' + eraseDown);
+}
+// ---------------------------------------------------------------- keys
+function readKey() {
+    return new Promise((resolve) => {
+        process.stdin.once('data', (d) => resolve(d.toString('utf8')));
+    });
+}
+// ---------------------------------------------------------------- helpers
+function openUrl(url) {
+    const platform = process.platform;
+    let cmd;
+    let args;
+    if (platform === 'darwin') {
+        cmd = 'open';
+        args = [url];
+    }
+    else if (platform === 'win32') {
+        cmd = 'cmd';
+        args = ['/c', 'start', '', url.replace(/&/g, '^&')];
+    }
+    else {
+        cmd = 'xdg-open';
+        args = [url];
+    }
+    try {
+        spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
+    }
+    catch {
+        /* spawn failed — surface as message upstream */
+    }
+}
+function respawn() {
+    // Re-exec this same CLI (preserves flags like --tui).
+    const child = spawn(process.execPath, process.argv.slice(1), {
+        stdio: 'inherit',
+        detached: true,
+    });
+    child.unref();
+}
+// ---------------------------------------------------------------- actions
+async function openDashboard() {
+    const url = `http://localhost:${cfg.port}`;
+    openUrl(url);
+    screen = { name: 'message', title: 'Dashboard opened in your browser', lines: [url], ok: true };
+}
+async function runUpdateCheck() {
+    screen = { name: 'check', spinner: 0 };
+    draw();
+    const tick = setInterval(() => {
+        if (screen.name === 'check') {
+            screen.spinner++;
+            draw();
+        }
+    }, 120);
+    let result;
+    try {
+        result = await getSelfUpdater().check(true);
+    }
+    catch {
+        result = {
+            currentVersion: getAppVersion(),
+            latestVersion: null,
+            hasUpdate: false,
+            changelogUrl: null,
+            checkedAt: new Date().toISOString(),
+            watchtowerReachable: null,
+        };
+    }
+    finally {
+        clearInterval(tick);
+    }
+    screen = { name: 'checkResult', result, sel: 0 };
+    draw();
+}
+async function applyUpdate(result) {
+    const to = result.latestVersion;
+    if (!to)
+        return;
+    screen = { name: 'applying', spinner: 0, to };
+    draw();
+    const tick = setInterval(() => {
+        if (screen.name === 'applying') {
+            screen.spinner++;
+            draw();
+        }
+    }, 120);
+    try {
+        await getSelfUpdater().run();
+        clearInterval(tick);
+        screen = { name: 'updated', from: result.currentVersion, to, sel: 0 };
+        draw();
+    }
+    catch (e) {
+        clearInterval(tick);
+        screen = {
+            name: 'message',
+            title: 'Update failed',
+            lines: [e.message],
+            ok: false,
+        };
+        draw();
+    }
+}
+// ---------------------------------------------------------------- lifecycle
+let shuttingDown = false;
+function shutdown(code = 0, respawnAfter = false) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    out(showCursor);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(false);
+    process.stdin.pause();
+    void (async () => {
+        try {
+            if (app)
+                await app.close();
+        }
+        catch {
+            /* already closing */
+        }
+        finally {
+            closeDb();
+            if (respawnAfter)
+                respawn();
+            process.exit(code);
+        }
+    })();
+}
+export async function runCliTui() {
+    // Keep the TUI clean: suppress routine logs (fatal only). Must be set before
+    // loadConfig() reads it.
+    if (!process.env.LATEDEV_LOG_LEVEL)
+        process.env.LATEDEV_LOG_LEVEL = 'fatal';
+    cfg = loadConfig();
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        // No interactive terminal — fall back to the plain server.
+        const { startApp } = await import('../../app.js');
+        await startApp();
+        return;
+    }
+    process.on('SIGINT', () => shutdown(0));
+    process.on('SIGTERM', () => shutdown(0));
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    out(hideCursor);
+    try {
+        app = await buildApp(); // opens the DB + runs migrations
+        await app.ready();
+        await app.listen({ host: cfg.host, port: cfg.port });
+    }
+    catch (e) {
+        out(showCursor);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        process.stderr.write(`Fatal: ${e.message}\n`);
+        closeDb();
+        process.exit(1);
+    }
+    startedAt = Date.now();
+    screen = { name: 'menu' };
+    draw();
+    // Live uptime + spinner redraw.
+    setInterval(() => {
+        if (screen.name === 'menu' || screen.name === 'check' || screen.name === 'applying')
+            draw();
+    }, 1000).unref();
+    for (;;) {
+        const key = await readKey();
+        if (key === KEY.ctrlC || key === KEY.esc) {
+            shutdown(0);
+            return;
+        }
+        // Key handling per screen. Snapshot the discriminant once — assignments
+        // to `screen` inside branches would otherwise re-narrow it mid-chain.
+        const screenName = screen.name;
+        if (screenName === 'menu') {
+            if (key === KEY.enter || key === KEY.newline || key === KEY.space) {
+                if (menuSel === 0)
+                    await openDashboard();
+                else if (menuSel === 1)
+                    await runUpdateCheck();
+                else {
+                    shutdown(0);
+                    return;
+                }
+            }
+            else if (key === KEY.up || key === 'k') {
+                menuSel = (menuSel + 2) % 3;
+            }
+            else if (key === KEY.down || key === 'j') {
+                menuSel = (menuSel + 1) % 3;
+            }
+            else if (key === 'q') {
+                shutdown(0);
+                return;
+            }
+        }
+        else if (screenName === 'checkResult') {
+            const cur = screen;
+            const hasChoice = cur.result.hasUpdate && cur.result.latestVersion !== null;
+            const count = hasChoice ? 2 : 1;
+            if (key === KEY.up || key === 'k') {
+                screen = { ...cur, sel: (cur.sel + count - 1) % count };
+            }
+            else if (key === KEY.down || key === 'j') {
+                screen = { ...cur, sel: (cur.sel + 1) % count };
+            }
+            else if (key === KEY.enter || key === KEY.newline || key === KEY.space) {
+                if (hasChoice && cur.sel === 0)
+                    await applyUpdate(cur.result);
+                else
+                    screen = { name: 'menu' };
+            }
+            else if (key === 'q' || key === 'b') {
+                screen = { name: 'menu' };
+            }
+        }
+        else if (screenName === 'updated') {
+            const cur = screen;
+            if (key === KEY.up || key === KEY.down || key === 'k' || key === 'j') {
+                screen = { ...cur, sel: (cur.sel + 1) % 2 };
+            }
+            else if (key === KEY.enter || key === KEY.newline || key === KEY.space) {
+                if (cur.sel === 0) {
+                    shutdown(0, true);
+                    return;
+                }
+                shutdown(0);
+                return;
+            }
+            else if (key === 'q') {
+                shutdown(0);
+                return;
+            }
+        }
+        else if (screenName === 'message') {
+            if (key === KEY.enter || key === KEY.newline || key === KEY.space || key === 'q' || key === 'b') {
+                screen = { name: 'menu' };
+            }
+        }
+        // 'check' and 'applying' screens ignore input while busy.
+        draw();
+    }
+}

package/dist/server/config/index.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import { getAppVersion } from '../version.js';
+const EnvSchema = z.object({
+    LATEDEV_HOST: z.string().default('0.0.0.0'),
+    // Port 0 is valid: it means "OS-assigned random port" (used by tests and dev).
+    LATEDEV_PORT: z.coerce.number().int().min(0).max(65535).default(8787),
+    LATEDEV_DATA_DIR: z.string().optional(),
+    LATEDEV_MASTER_KEY: z.string().optional(),
+    LATEDEV_TRUST_PROXY: z.coerce.number().int().min(0).max(8).default(0),
+    LATEDEV_LOG_LEVEL: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']).default('info'),
+    LATEDEV_DB_URL: z.string().optional(),
+    NODE_ENV: z.enum(['development', 'production', 'test']).default('production'),
+});
+let cached = null;
+/** Empty-string env vars (e.g. `LATEDEV_MASTER_KEY:` in docker-compose) must not
+ *  shadow real defaults — treat them as unset. */
+function normalizeEnv(env) {
+    const out = { ...env };
+    for (const k of Object.keys(out)) {
+        if (out[k] === '')
+            delete out[k];
+    }
+    return out;
+}
+function readMasterKeyFile(dataDir) {
+    try {
+        const p = path.join(dataDir, 'master.key');
+        if (fs.existsSync(p)) {
+            return fs.readFileSync(p, 'utf8').trim();
+        }
+    }
+    catch {
+        /* ignore unreadable file — treat as absent */
+    }
+    return null;
+}
+export function loadConfig(env = process.env, argv = process.argv) {
+    if (cached)
+        return cached;
+    const parsed = EnvSchema.parse(normalizeEnv(env));
+    const cliArgs = parseArgs(argv);
+    const dataDir = cliArgs.dataDir ??
+        parsed.LATEDEV_DATA_DIR ??
+        (parsed.NODE_ENV === 'test' ? path.resolve('../.tmp/test-data') : path.resolve(os.homedir(), '.latedev-router'));
+    const isContainer = Boolean(env.LATEDEV_DATA_DIR?.startsWith('/data') || process.env.CONTAINER === '1');
+    const dbFile = parsed.LATEDEV_DB_URL ?? path.join(dataDir, 'data.sqlite');
+    cached = {
+        host: cliArgs.host ?? parsed.LATEDEV_HOST,
+        port: cliArgs.port ?? parsed.LATEDEV_PORT,
+        dataDir,
+        dbFile,
+        masterKey: parsed.LATEDEV_MASTER_KEY ?? readMasterKeyFile(dataDir),
+        trustProxyHops: parsed.LATEDEV_TRUST_PROXY,
+        logLevel: parsed.LATEDEV_LOG_LEVEL,
+        env: parsed.NODE_ENV,
+        isContainer,
+        appVersion: getAppVersion(),
+    };
+    return cached;
+}
+export function resetConfigForTests() {
+    cached = null;
+}
+export function setConfigMasterKey(key) {
+    process.env.LATEDEV_MASTER_KEY = key; // future loadConfig reads pick it up
+    if (cached) {
+        cached.masterKey = key;
+    }
+}
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--host' && argv[i + 1]) {
+            out.host = argv[++i];
+        }
+        else if (a?.startsWith('--host=')) {
+            out.host = a.split('=')[1];
+        }
+        else if (a === '--port' && argv[i + 1]) {
+            out.port = Number(argv[++i]);
+        }
+        else if (a?.startsWith('--port=')) {
+            out.port = Number(a.split('=')[1]);
+        }
+        else if (a === '--data-dir' && argv[i + 1]) {
+            out.dataDir = argv[++i];
+        }
+        else if (a?.startsWith('--data-dir=')) {
+            out.dataDir = a.split('=')[1];
+        }
+    }
+    return out;
+}

package/dist/server/db/index.js

@@ -0,0 +1,64 @@
+// Database bootstrap: opens SQLite WAL, applies pending migrations, returns a Drizzle DB handle.
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as schema from './schema.js';
+import { getLogger } from '../logging/logger.js';
+import { runMigrations } from './migrate.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/** Locate the migrations directory across the possible layouts:
+ *  - Docker dist:          dist/server/db → ../../migrations   (dist/migrations)
+ *  - npm package dist:     dist/server/db → ../../../migrations (<pkg>/migrations)
+ *  - source tree (dev/test): src/server/db → ../../../migrations (repo/migrations)
+ */
+function resolveMigrationsDir() {
+    const distDir = path.resolve(__dirname, '../../migrations');
+    const rootDir = path.resolve(__dirname, '../../../migrations');
+    if (fs.existsSync(distDir))
+        return distDir;
+    if (fs.existsSync(rootDir))
+        return rootDir;
+    return distDir; // let runMigrations log the missing-dir fallback
+}
+let _db = null;
+let _raw = null;
+export function openDb(dbFile) {
+    if (_db && _raw)
+        return { db: _db, raw: _raw };
+    const dir = path.dirname(dbFile);
+    if (dir && !fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const raw = new Database(dbFile);
+    // Pragmas for WAL + safety
+    raw.pragma('journal_mode = WAL');
+    raw.pragma('synchronous = NORMAL');
+    raw.pragma('foreign_keys = ON');
+    raw.pragma('busy_timeout = 5000');
+    raw.pragma('temp_store = MEMORY');
+    raw.pragma('cache_size = -20000');
+    const db = drizzle(raw, { schema });
+    _raw = raw;
+    _db = db;
+    runMigrations(raw, getLogger(), resolveMigrationsDir());
+    return { db, raw };
+}
+export function closeDb() {
+    if (_raw) {
+        try {
+            _raw.close();
+        }
+        catch (e) {
+            getLogger().warn({ err: String(e) }, 'failed to close db');
+        }
+        _raw = null;
+        _db = null;
+    }
+}
+export function getDb() {
+    if (!_db)
+        throw new Error('Database not opened');
+    return _db;
+}
+export { schema };