@calltelemetry/cli 0.4.26 → 0.5.1

package/dist/shell/commands/show.js

@@ -0,0 +1,897 @@
+import { execa } from 'execa';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { table, kv, statusLine, banner } from '../formatter.js';
+import { getAppHealth } from '../../lib/rpc.js';
+import { rpc } from '../../lib/rpc.js';
+import { getServiceList } from '../../lib/services.js';
+import { compose, composeExec } from '../../lib/compose.js';
+import { getSystemStats, getDockerVersion, formatBytes } from '../../lib/system.js';
+import { DB_USER, DB_NAME, PG_ENV } from '../../lib/db.js';
+import { getPaths } from '../../lib/paths.js';
+import { getIpv6Status } from '../../lib/ipv6.js';
+import { isOtelEnabled } from '../../lib/otel.js';
+import { getPostgresVersion } from '../../lib/postgres.js';
+import { getSecrets, SECRET_CATALOG, SECRET_GROUPS, countOverrides } from '../../lib/secrets.js';
+import { isJtapiEnabled, getJtapiHealthCheck } from '../../lib/jtapi.js';
+import { Status, thresholdColor, visibleLength } from '../theme.js';
+// ── Helpers ──
+async function psqlTerse(query) {
+    const result = await composeExec('db', ['psql', '-U', DB_USER, '-d', DB_NAME, '-t', '-c', query], { env: PG_ENV, pipe: true });
+    return (result.stdout ?? '').trim();
+}
+/** Inline meter bar: ████████░░░░░░░░ 12/100 (12%) */
+function meterBar(current, max, width = 20) {
+    const pct = max > 0 ? Math.min(100, Math.round((current / max) * 100)) : 0;
+    const filled = Math.round((pct / 100) * width);
+    const empty = width - filled;
+    const color = thresholdColor(pct);
+    const bar = color('\u2588'.repeat(filled)) + chalk.dim('\u2591'.repeat(empty));
+    return `${bar} ${current.toLocaleString()}/${max.toLocaleString()} (${pct}%)`;
+}
+/** Size bar for table rows — proportional to max value */
+function sizeBar(bytes, maxBytes, width = 10) {
+    if (maxBytes <= 0)
+        return '\u2591'.repeat(width);
+    const pct = Math.min(100, Math.round((bytes / maxBytes) * 100));
+    const filled = Math.max(1, Math.round((pct / 100) * width));
+    const empty = width - filled;
+    return chalk.cyan('\u2588'.repeat(filled)) + chalk.dim('\u2591'.repeat(empty));
+}
+/** Loading spinner — writes to stdout and returns a clear function */
+function showSpinner(label) {
+    const text = `  ${Status.running.color(Status.running.symbol)} ${chalk.cyan(label)}`;
+    process.stdout.write(text + '\r');
+    return () => {
+        process.stdout.write(' '.repeat(visibleLength(text) + 2) + '\r');
+    };
+}
+/** Format a service state with colored dot */
+function serviceState(state, health) {
+    const s = state.toLowerCase();
+    const h = (health ?? '').toLowerCase();
+    if (s === 'running' && h === 'healthy') {
+        return `${Status.online.color(Status.online.symbol)} Running`;
+    }
+    if (s === 'running' && h === 'unhealthy') {
+        return `${Status.degraded.color(Status.degraded.symbol)} Degraded`;
+    }
+    if (s === 'running') {
+        return `${Status.online.color(Status.online.symbol)} Running`;
+    }
+    if (s === 'exited' || s === 'stopped') {
+        return `${Status.offline.color(Status.offline.symbol)} Stopped`;
+    }
+    if (s === 'restarting') {
+        return `${Status.warn.color(Status.warn.symbol)} Restarting`;
+    }
+    return `${Status.waiting.color(Status.waiting.symbol)} ${state}`;
+}
+/** Parse size string like "1.8 GB", "256 MB", "48 kB" into bytes for comparison */
+function parseSizeToBytes(sizeStr) {
+    const match = sizeStr.trim().match(/^([\d.]+)\s*(bytes|kB|MB|GB|TB)/i);
+    if (!match)
+        return 0;
+    const num = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    const multipliers = {
+        bytes: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3, tb: 1024 ** 4,
+    };
+    return num * (multipliers[unit] ?? 0);
+}
+// ── show health ──
+export async function showHealth(_args, _opts, _ctx) {
+    const clear = showSpinner('Checking system health...');
+    try {
+        const h = await getAppHealth();
+        clear();
+        console.log(banner('System Health'));
+        // Build check list with severity
+        const checks = [
+            { label: 'Admin API', ok: h.api, detail: h.apiError },
+            { label: 'CURRI API', ok: h.curri, detail: h.curriError },
+            { label: 'RPC', ok: h.rpc, detail: h.rpcError },
+            { label: 'DB Pool', ok: h.dbConnected, detail: h.dbError },
+            { label: 'DB Direct', ok: h.dbDirect, detail: h.dbDirectError },
+            { label: 'CURRI Proxy', ok: h.curriProxy, detail: h.curriProxyError },
+            { label: 'Admin Proxy', ok: h.adminProxy, detail: h.adminProxyError },
+            { label: 'SFTP', ok: h.sftp, detail: h.sftpError },
+        ];
+        const failures = checks.filter(c => !c.ok);
+        const healthy = checks.filter(c => c.ok);
+        // Show failures first (critical)
+        if (failures.length > 0) {
+            console.log(chalk.red.bold('\n  CRITICAL'));
+            for (const f of failures) {
+                console.log(`  ${statusLine(f.label, 'fail', f.detail)}`);
+            }
+        }
+        // Show healthy checks
+        if (healthy.length > 0) {
+            console.log(chalk.green.bold('\n  HEALTHY'));
+            for (const h of healthy) {
+                console.log(`  ${statusLine(h.label, 'ok')}`);
+            }
+        }
+        // Overall verdict
+        const overallStatus = h.overall === 'healthy' ? 'ok' : h.overall === 'degraded' ? 'warn' : 'fail';
+        const overallLabel = h.overall === 'healthy'
+            ? `All ${checks.length} checks passing`
+            : h.overall === 'degraded'
+                ? `${failures.length} of ${checks.length} checks failing`
+                : `${failures.length} of ${checks.length} checks failing`;
+        console.log(`\n  ${statusLine('Overall', overallStatus, overallLabel)}`);
+        console.log();
+    }
+    catch (err) {
+        clear();
+        console.log(banner('System Health'));
+        console.log(statusLine('Health Check', 'fail', err.message));
+    }
+}
+// ── show version ──
+export async function showVersion(_args, _opts, _ctx) {
+    const clear = showSpinner('Gathering version info...');
+    const pairs = [];
+    // CLI version from package
+    try {
+        const pkg = await import('../../../package.json', { with: { type: 'json' } });
+        pairs.push(['CLI Version', chalk.bold(pkg.default?.version ?? 'unknown')]);
+    }
+    catch {
+        pairs.push(['CLI Version', chalk.dim('unknown')]);
+    }
+    // App version via RPC
+    try {
+        const out = await rpc(':application.loaded_applications() |> Enum.find(fn {app, _, _} -> app == :cdrcisco end) |> elem(2) |> to_string() |> IO.puts()');
+        pairs.push(['App Version', chalk.bold(out.trim() || 'unknown')]);
+    }
+    catch {
+        pairs.push(['App Version', chalk.dim('unavailable')]);
+    }
+    // Docker version
+    try {
+        const dv = await getDockerVersion();
+        pairs.push(['Docker', dv ? `${dv}` : chalk.dim('unavailable')]);
+    }
+    catch {
+        pairs.push(['Docker', chalk.dim('unavailable')]);
+    }
+    // System stats
+    try {
+        const stats = await getSystemStats();
+        pairs.push(['System', stats]);
+    }
+    catch {
+        pairs.push(['System', chalk.dim('unavailable')]);
+    }
+    clear();
+    console.log(banner('Version Information'));
+    console.log(kv(pairs));
+}
+// ── show services ──
+export async function showServices(_args, _opts, _ctx) {
+    const clear = showSpinner('Querying services...');
+    try {
+        const services = await getServiceList();
+        clear();
+        if (services.length === 0) {
+            console.log(banner('Services'));
+            console.log(statusLine('Services', 'warn', 'No services found. Is Docker Compose running?'));
+            return;
+        }
+        // Count by state for summary
+        const running = services.filter(s => s.state.toLowerCase() === 'running').length;
+        const stopped = services.length - running;
+        console.log(banner('Services'));
+        console.log(chalk.dim(`  ${running} running, ${stopped} stopped, ${services.length} total\n`));
+        const rows = services.map(s => [
+            s.service,
+            serviceState(s.state, s.health),
+            s.status || chalk.dim('-'),
+            s.ports || chalk.dim('-'),
+        ]);
+        console.log(table(['Name', 'State', 'Status', 'Ports'], rows));
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Services'));
+        console.log(statusLine('Services', 'fail', err.message));
+    }
+}
+// ── show connections ──
+export async function showConnections(_args, _opts, ctx) {
+    console.log(banner('MCP Connections'));
+    if (ctx.connections.size === 0) {
+        console.log(statusLine('Connections', 'info', 'No active connections'));
+        return;
+    }
+    const rows = [];
+    for (const [name, conn] of ctx.connections) {
+        rows.push([name, conn.type, `${Status.online.color(Status.online.symbol)} connected`]);
+    }
+    console.log(table(['Name', 'Type', 'Status'], rows));
+}
+// ── show db status ──
+export async function showDbStatus(_args, _opts, _ctx) {
+    const clear = showSpinner('Checking database...');
+    try {
+        // Run checks in parallel
+        const [, size, connInfo] = await Promise.all([
+            composeExec('db', ['pg_isready', '-U', DB_USER, '-d', DB_NAME], { pipe: true }),
+            psqlTerse(`SELECT pg_size_pretty(pg_database_size('${DB_NAME}'));`),
+            psqlTerse(`SELECT count(*) FROM pg_stat_activity WHERE datname = '${DB_NAME}';`).catch(() => null),
+        ]);
+        // Try to get max connections
+        let maxConns = null;
+        try {
+            maxConns = await psqlTerse(`SHOW max_connections;`);
+        }
+        catch { /* ignore */ }
+        clear();
+        console.log(banner('Database Status'));
+        console.log(statusLine('PostgreSQL', 'ok', 'accepting connections'));
+        console.log(statusLine('Database Size', 'info', size));
+        // Connection pool meter bar
+        if (connInfo && maxConns) {
+            const current = parseInt(connInfo, 10) || 0;
+            const max = parseInt(maxConns, 10) || 100;
+            console.log(`\n  ${chalk.bold('Connections')}: ${meterBar(current, max)}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Database Status'));
+        console.log(statusLine('PostgreSQL', 'fail', err.message));
+    }
+}
+// ── show db tables ──
+export async function showDbTables(args, _opts, _ctx) {
+    const clear = showSpinner('Querying tables...');
+    try {
+        const nameFilter = args[0];
+        let query = `SELECT tablename, pg_size_pretty(pg_total_relation_size(quote_ident(tablename))) AS size, pg_total_relation_size(quote_ident(tablename)) AS raw_size FROM pg_tables WHERE schemaname = 'public'`;
+        if (nameFilter) {
+            query += ` AND tablename LIKE '%${nameFilter}%'`;
+        }
+        query += ' ORDER BY pg_total_relation_size(quote_ident(tablename)) DESC LIMIT 30;';
+        // Also get row counts for each table
+        const countQuery = nameFilter
+            ? `SELECT relname, n_live_tup FROM pg_stat_user_tables WHERE relname LIKE '%${nameFilter}%' ORDER BY n_live_tup DESC LIMIT 30;`
+            : `SELECT relname, n_live_tup FROM pg_stat_user_tables ORDER BY n_live_tup DESC LIMIT 30;`;
+        const [result, countResult] = await Promise.all([
+            psqlTerse(query),
+            psqlTerse(countQuery).catch(() => ''),
+        ]);
+        clear();
+        if (!result) {
+            console.log(banner('Database Tables'));
+            console.log(statusLine('Tables', 'info', 'No tables found'));
+            return;
+        }
+        // Parse row counts into a map
+        const rowCounts = new Map();
+        if (countResult) {
+            for (const line of countResult.split('\n')) {
+                if (!line.includes('|'))
+                    continue;
+                const [name, count] = line.split('|').map(c => c.trim());
+                if (name && count)
+                    rowCounts.set(name, parseInt(count, 10) || 0);
+            }
+        }
+        // Parse table data
+        const parsed = result.split('\n')
+            .filter(line => line.includes('|'))
+            .map(line => {
+            const cols = line.split('|').map(c => c.trim());
+            return {
+                name: cols[0] ?? '',
+                size: cols[1] ?? '',
+                rawSize: parseInt(cols[2] ?? '0', 10) || 0,
+            };
+        });
+        const maxSize = parsed.length > 0 ? parsed[0].rawSize : 0;
+        console.log(banner('Database Tables'));
+        console.log(chalk.dim(`  ${parsed.length} tables, sorted by size\n`));
+        const rows = parsed.map(t => {
+            const bar = sizeBar(t.rawSize, maxSize, 10);
+            const count = rowCounts.get(t.name);
+            const countStr = count !== undefined ? `${count.toLocaleString()} rows` : chalk.dim('-');
+            return [t.name, `${bar} ${t.size}`, countStr];
+        });
+        console.log(table(['Table', 'Size', 'Rows'], rows));
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Database Tables'));
+        console.log(statusLine('Tables', 'fail', err.message));
+    }
+}
+// ── show db size ──
+export async function showDbSize(_args, _opts, _ctx) {
+    const clear = showSpinner('Calculating database size...');
+    try {
+        const [totalSize, tableCount, top] = await Promise.all([
+            psqlTerse(`SELECT pg_size_pretty(pg_database_size('${DB_NAME}'));`),
+            psqlTerse(`SELECT count(*) FROM pg_tables WHERE schemaname = 'public';`),
+            psqlTerse(`SELECT tablename, pg_size_pretty(pg_total_relation_size(quote_ident(tablename))), pg_total_relation_size(quote_ident(tablename)) FROM pg_tables WHERE schemaname = 'public' ORDER BY pg_total_relation_size(quote_ident(tablename)) DESC LIMIT 5;`),
+        ]);
+        clear();
+        console.log(banner('Database Size'));
+        console.log(kv([
+            ['Total Size', chalk.bold(totalSize)],
+            ['Table Count', tableCount],
+        ]));
+        if (top) {
+            const parsed = top.split('\n')
+                .filter(line => line.includes('|'))
+                .map(line => {
+                const cols = line.split('|').map(c => c.trim());
+                return { name: cols[0] ?? '', size: cols[1] ?? '', rawSize: parseInt(cols[2] ?? '0', 10) || 0 };
+            });
+            const maxSize = parsed.length > 0 ? parsed[0].rawSize : 0;
+            console.log(banner('Top 5 Tables'));
+            const rows = parsed.map(t => [
+                t.name,
+                `${sizeBar(t.rawSize, maxSize, 12)} ${t.size}`,
+            ]);
+            console.log(table(['Table', 'Size'], rows));
+        }
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Database Size'));
+        console.log(statusLine('DB Size', 'fail', err.message));
+    }
+}
+// ── show db backups ──
+export async function showDbBackups(_args, _opts, _ctx) {
+    const { backupDir, dbDumpsDir } = getPaths();
+    console.log(banner('Database Backups'));
+    for (const [label, dir] of [['Backups', backupDir], ['DB Dumps', dbDumpsDir]]) {
+        if (!existsSync(dir)) {
+            console.log(statusLine(label, 'info', `${dir} does not exist`));
+            continue;
+        }
+        try {
+            const files = readdirSync(dir).filter(f => f.endsWith('.sql') || f.endsWith('.gz') || f.endsWith('.dump'));
+            if (files.length === 0) {
+                console.log(statusLine(label, 'info', 'no backups found'));
+            }
+            else {
+                console.log(statusLine(label, 'ok', `${files.length} file(s)`));
+                // Show recent files with sizes
+                const recent = files.slice(-10);
+                for (const f of recent) {
+                    try {
+                        const st = statSync(join(dir, f));
+                        const size = formatBytes(st.size);
+                        const date = st.mtime.toLocaleDateString();
+                        console.log(`    ${chalk.dim(date)}  ${f}  ${chalk.dim(size)}`);
+                    }
+                    catch {
+                        console.log(`    ${f}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.log(statusLine(label, 'fail', err.message));
+        }
+    }
+}
+// ── show migrate status ──
+export async function showMigrateStatus(_args, _opts, _ctx) {
+    const clear = showSpinner('Checking migrations...');
+    try {
+        const out = await rpc('Ecto.Migrator.migrations(Cdrcisco.Repo) |> Enum.map(fn {status, version, name} -> "#{status}|#{version}|#{name}" end) |> Enum.join("\\n") |> IO.puts()');
+        clear();
+        console.log(banner('Migration Status'));
+        const lines = out.trim().split('\n').filter(l => l.includes('|'));
+        if (lines.length === 0) {
+            console.log(statusLine('Migrations', 'info', 'No migrations found'));
+            return;
+        }
+        const upCount = lines.filter(l => l.startsWith('up')).length;
+        const downCount = lines.filter(l => l.startsWith('down')).length;
+        console.log(chalk.dim(`  ${upCount} applied, ${downCount} pending\n`));
+        const rows = lines.map(line => {
+            const [status, version, name] = line.split('|').map(c => c.trim());
+            const isUp = status === 'up';
+            const stateStr = isUp
+                ? `${Status.ok.color(Status.ok.symbol)} up`
+                : `${Status.warn.color(Status.warn.symbol)} down`;
+            return [stateStr, version ?? '', name ?? ''];
+        });
+        console.log(table(['Status', 'Version', 'Name'], rows));
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Migration Status'));
+        console.log(statusLine('Migrations', 'fail', err.message));
+    }
+}
+// ── show migrate history ──
+export async function showMigrateHistory(_args, _opts, _ctx) {
+    const clear = showSpinner('Loading migration history...');
+    try {
+        const result = await psqlTerse(`SELECT version, inserted_at FROM schema_migrations ORDER BY version DESC LIMIT 20;`);
+        clear();
+        if (!result) {
+            console.log(banner('Migration History'));
+            console.log(statusLine('History', 'info', 'No migration history found'));
+            return;
+        }
+        console.log(banner('Migration History'));
+        const rows = result.split('\n')
+            .filter(line => line.includes('|'))
+            .map(line => {
+            const cols = line.split('|').map(c => c.trim());
+            return [cols[0] ?? '', cols[1] ?? ''];
+        });
+        console.log(table(['Version', 'Applied At'], rows));
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Migration History'));
+        console.log(statusLine('Migration History', 'fail', err.message));
+    }
+}
+// ── show docker status ──
+export async function showDockerStatus(_args, _opts, _ctx) {
+    const clear = showSpinner('Querying containers...');
+    try {
+        const result = await compose(['ps', '-a', '--format', 'json'], { pipe: true });
+        const raw = (result.stdout ?? '').trim();
+        clear();
+        if (!raw) {
+            console.log(banner('Docker Containers'));
+            console.log(statusLine('Containers', 'info', 'No containers found'));
+            return;
+        }
+        const containers = raw.split('\n')
+            .filter(line => line.trim())
+            .map(line => JSON.parse(line));
+        const running = containers.filter(c => (c.State ?? '').toLowerCase() === 'running').length;
+        console.log(banner('Docker Containers'));
+        console.log(chalk.dim(`  ${running} running, ${containers.length - running} stopped, ${containers.length} total\n`));
+        const rows = containers.map(obj => [
+            obj.Name ?? obj.Names ?? '',
+            serviceState(obj.State ?? '', obj.Health ?? ''),
+            obj.Status ?? chalk.dim('-'),
+            obj.Ports ?? chalk.dim('-'),
+        ]);
+        console.log(table(['Name', 'State', 'Status', 'Ports'], rows));
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Docker Containers'));
+        console.log(statusLine('Docker', 'fail', err.message));
+    }
+}
+// ── show docker network ──
+export async function showDockerNetwork(_args, _opts, _ctx) {
+    const clear = showSpinner('Querying networks...');
+    try {
+        const { stdout } = await execa('docker', ['network', 'ls', '--format', 'json']);
+        clear();
+        console.log(banner('Docker Networks'));
+        const lines = stdout.trim().split('\n').filter(l => l.trim());
+        if (lines.length === 0) {
+            console.log(statusLine('Networks', 'info', 'No networks found'));
+            return;
+        }
+        const rows = lines.map(line => {
+            try {
+                const obj = JSON.parse(line);
+                return [
+                    obj.Name ?? '',
+                    obj.Driver ?? '',
+                    obj.Scope ?? '',
+                ];
+            }
+            catch {
+                return [line, '', ''];
+            }
+        });
+        console.log(table(['Name', 'Driver', 'Scope'], rows));
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Docker Networks'));
+        console.log(statusLine('Docker Networks', 'fail', err.message));
+    }
+}
+// ── show config certs ──
+export async function showConfigCerts(_args, _opts, _ctx) {
+    const { certsDir } = getPaths();
+    console.log(banner('TLS Certificates'));
+    const certFile = join(certsDir, 'appliance.crt');
+    if (!existsSync(certFile)) {
+        console.log(statusLine('Certificate', 'warn', 'no certificate found'));
+        return;
+    }
+    try {
+        const { stdout } = await execa('openssl', ['x509', '-in', certFile, '-noout', '-dates', '-subject']);
+        const lines = stdout.split('\n');
+        const pairs = [];
+        for (const l of lines) {
+            if (!l.includes('='))
+                continue;
+            const [k, ...rest] = l.split('=');
+            const key = k.trim();
+            const value = rest.join('=').trim();
+            // Highlight expiry dates
+            if (key === 'notAfter') {
+                const expiry = new Date(value);
+                const now = new Date();
+                const daysLeft = Math.floor((expiry.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+                const color = daysLeft < 30 ? chalk.red : daysLeft < 90 ? chalk.yellow : chalk.green;
+                pairs.push([key, `${value} ${color(`(${daysLeft} days remaining)`)}`]);
+            }
+            else {
+                pairs.push([key, value]);
+            }
+        }
+        console.log(kv(pairs));
+    }
+    catch (err) {
+        console.log(statusLine('Certificate', 'fail', err.message));
+    }
+}
+// ── show config logging ──
+export async function showConfigLogging(_args, _opts, _ctx) {
+    console.log(banner('Logging Configuration'));
+    try {
+        const out = await rpc('Logger.level() |> IO.inspect()');
+        const level = out.trim().replace(/^:/, '');
+        const levelColor = level === 'debug' ? chalk.cyan : level === 'info' ? chalk.green : level === 'warning' ? chalk.yellow : level === 'error' ? chalk.red : chalk.white;
+        console.log(kv([['Log Level', levelColor(level)]]));
+    }
+    catch {
+        console.log(kv([['Log Level', chalk.dim('unavailable (app not running)')]]));
+    }
+}
+// ── show config ipv6 ──
+export async function showConfigIpv6(_args, _opts, _ctx) {
+    const status = getIpv6Status();
+    console.log(banner('IPv6 Configuration'));
+    const statusMap = {
+        enabled: 'ok', disabled: 'info', unknown: 'warn',
+    };
+    console.log(statusLine('IPv6', statusMap[status] ?? 'info', status));
+}
+// ── show config otel ──
+export async function showConfigOtel(_args, _opts, _ctx) {
+    const enabled = isOtelEnabled();
+    console.log(banner('OpenTelemetry'));
+    console.log(statusLine('OTel', enabled ? 'ok' : 'info', enabled ? 'enabled' : 'disabled'));
+    if (enabled) {
+        console.log(chalk.dim('  Traces and metrics exported via OTLP'));
+    }
+}
+// ── show config postgres ──
+export async function showConfigPostgres(_args, _opts, _ctx) {
+    const version = getPostgresVersion();
+    console.log(banner('PostgreSQL Configuration'));
+    console.log(kv([
+        ['Configured Version', chalk.bold(version)],
+        ['Database', DB_NAME],
+        ['User', DB_USER],
+    ]));
+}
+// ── show config secrets ──
+export async function showConfigSecrets(_args, _opts, _ctx) {
+    const overrides = countOverrides();
+    const secrets = getSecrets();
+    console.log(banner('Secrets'));
+    const overrideStatus = overrides > 0 ? 'ok' : 'warn';
+    const overrideDetail = overrides > 0
+        ? `${overrides} of ${SECRET_CATALOG.length} customized from defaults`
+        : `All ${SECRET_CATALOG.length} secrets using defaults ${chalk.yellow('(insecure)')}`;
+    console.log(statusLine('Customized', overrideStatus, overrideDetail));
+    // Group by category
+    for (const group of SECRET_GROUPS) {
+        const groupSecrets = SECRET_CATALOG.filter(d => d.group === group);
+        if (groupSecrets.length === 0)
+            continue;
+        console.log(chalk.bold(`\n  ${group}`));
+        for (const def of groupSecrets) {
+            const val = secrets[def.key] ?? def.defaultValue;
+            const isDefault = val === def.defaultValue;
+            let display;
+            if (def.sensitive) {
+                if (isDefault) {
+                    display = chalk.yellow('(default)');
+                }
+                else {
+                    // Masked with stars, show first/last char hint
+                    display = chalk.green('*'.repeat(8));
+                }
+            }
+            else {
+                display = isDefault ? chalk.dim(val) : chalk.white(val);
+            }
+            const customBadge = !isDefault ? chalk.green(' [custom]') : '';
+            console.log(`    ${chalk.dim(def.label.padEnd(20))} ${display}${customBadge}`);
+        }
+    }
+    console.log();
+}
+// ── show license ──
+export async function showLicense(_args, _opts, _ctx) {
+    const clear = showSpinner('Checking license...');
+    try {
+        const out = await rpc('case Cdrcisco.License.status() do ' +
+            '{:ok, info} -> info |> Jason.encode!() |> IO.puts(); ' +
+            '{:error, reason} -> IO.puts("error:#{reason}") ' +
+            'end');
+        const trimmed = out.trim();
+        clear();
+        console.log(banner('License'));
+        if (trimmed.startsWith('error:')) {
+            console.log(statusLine('License', 'warn', trimmed.replace('error:', '')));
+            return;
+        }
+        try {
+            const info = JSON.parse(trimmed);
+            const pairs = Object.entries(info).map(([k, v]) => {
+                const strVal = String(v);
+                // Highlight key license fields
+                if (k.toLowerCase().includes('expire') || k.toLowerCase().includes('valid')) {
+                    const isValid = strVal.toLowerCase() === 'true' || strVal.toLowerCase() === 'valid';
+                    return [k, isValid ? chalk.green(strVal) : chalk.red(strVal)];
+                }
+                return [k, strVal];
+            });
+            console.log(kv(pairs));
+        }
+        catch {
+            console.log(trimmed);
+        }
+    }
+    catch (err) {
+        clear();
+        console.log(banner('License'));
+        console.log(statusLine('License', 'fail', err.message));
+    }
+}
+// ── show jtapi status ──
+export async function showJtapiStatus(_args, _opts, _ctx) {
+    const enabled = isJtapiEnabled();
+    console.log(banner('JTAPI Status'));
+    console.log(statusLine('JTAPI', enabled ? 'ok' : 'info', enabled ? 'enabled' : 'disabled'));
+    if (enabled) {
+        const clear = showSpinner('Checking sidecar health...');
+        try {
+            const health = await getJtapiHealthCheck();
+            clear();
+            console.log(statusLine('Sidecar', health.reachable ? 'ok' : 'fail', health.status ?? (health.reachable ? 'reachable' : health.detail ?? 'unreachable')));
+        }
+        catch (err) {
+            clear();
+            console.log(statusLine('Sidecar', 'fail', err.message));
+        }
+    }
+}
+// ── show users ──
+export async function showUsers(_args, _opts, _ctx) {
+    const clear = showSpinner('Loading users...');
+    try {
+        const out = await rpc('Cdrcisco.Accounts.list_users() |> Enum.map(fn u -> "#{u.email}|#{u.role || "user"}|#{u.inserted_at}" end) |> Enum.join("\\n") |> IO.puts()');
+        const trimmed = out.trim();
+        clear();
+        if (!trimmed) {
+            console.log(banner('Users'));
+            console.log(statusLine('Users', 'info', 'No users found'));
+            return;
+        }
+        console.log(banner('Users'));
+        const rows = trimmed.split('\n').map(line => {
+            const [email, role, created] = line.split('|');
+            const roleBadge = role === 'admin'
+                ? chalk.magenta(role ?? '')
+                : chalk.dim(role ?? 'user');
+            return [email ?? '', roleBadge, created ?? ''];
+        });
+        console.log(chalk.dim(`  ${rows.length} user(s)\n`));
+        console.log(table(['Email', 'Role', 'Created'], rows));
+    }
+    catch (err) {
+        clear();
+        console.log(banner('Users'));
+        console.log(statusLine('Users', 'fail', err.message));
+    }
+}
+// ── show network ──
+export async function showNetwork(_args, _opts, _ctx) {
+    const clear = showSpinner('Scanning network interfaces...');
+    console.log(banner('Network Configuration'));
+    // Try ip addr first (Linux), fall back to ifconfig (macOS)
+    try {
+        const { stdout } = await execa('ip', ['-br', 'addr']);
+        clear();
+        const lines = stdout.trim().split('\n');
+        const rows = lines.map(line => {
+            const parts = line.trim().split(/\s+/);
+            const iface = parts[0] ?? '';
+            const state = (parts[1] ?? '').toUpperCase();
+            const addrs = parts.slice(2).join(', ') || chalk.dim('none');
+            let stateStr;
+            if (state === 'UP') {
+                stateStr = `${Status.online.color(Status.online.symbol)} UP`;
+            }
+            else if (state === 'DOWN') {
+                stateStr = `${Status.offline.color(Status.offline.symbol)} DOWN`;
+            }
+            else {
+                stateStr = `${Status.waiting.color(Status.waiting.symbol)} ${state}`;
+            }
+            return [iface, stateStr, addrs];
+        });
+        console.log(table(['Interface', 'State', 'Addresses'], rows));
+        return;
+    }
+    catch {
+        // ip not available, try ifconfig (macOS)
+    }
+    try {
+        const { stdout } = await execa('ifconfig');
+        clear();
+        // Parse macOS ifconfig into structured data
+        const interfaces = [];
+        let current = null;
+        for (const line of stdout.split('\n')) {
+            const ifMatch = line.match(/^(\w+):\s+flags=\d+<([^>]*)>/);
+            if (ifMatch) {
+                if (current)
+                    interfaces.push(current);
+                current = { name: ifMatch[1], state: ifMatch[2].includes('UP') ? 'UP' : 'DOWN', addresses: [] };
+            }
+            const inetMatch = line.match(/inet\s+(\S+)/);
+            if (inetMatch && current) {
+                current.addresses.push(inetMatch[1]);
+            }
+            const inet6Match = line.match(/inet6\s+(\S+)/);
+            if (inet6Match && current) {
+                current.addresses.push(inet6Match[1]);
+            }
+        }
+        if (current)
+            interfaces.push(current);
+        const rows = interfaces.map(iface => {
+            const stateStr = iface.state === 'UP'
+                ? `${Status.online.color(Status.online.symbol)} UP`
+                : `${Status.offline.color(Status.offline.symbol)} DOWN`;
+            const addrs = iface.addresses.length > 0 ? iface.addresses.join(', ') : chalk.dim('none');
+            return [iface.name, stateStr, addrs];
+        });
+        console.log(table(['Interface', 'State', 'Addresses'], rows));
+    }
+    catch {
+        clear();
+        console.log(statusLine('Network', 'fail', 'Unable to retrieve network information'));
+    }
+}
+// ── show os-updates status ──
+export async function showOsUpdatesStatus(_args, _opts, _ctx) {
+    console.log(banner('OS Update Status'));
+    // Try dnf-automatic (RHEL/AlmaLinux/Fedora)
+    try {
+        const { stdout } = await execa('systemctl', ['show', 'dnf-automatic-install.timer', '--property=ActiveState,SubState,NextElapseUSecRealtime']);
+        const props = {};
+        for (const line of stdout.split('\n')) {
+            const [k, ...rest] = line.split('=');
+            if (k)
+                props[k.trim()] = rest.join('=').trim();
+        }
+        const active = props.ActiveState === 'active';
+        const nextRun = props.NextElapseUSecRealtime;
+        console.log(statusLine('Auto-Update Timer', active ? 'ok' : 'warn', active ? 'active (dnf-automatic)' : 'inactive'));
+        if (nextRun && nextRun !== 'n/a') {
+            // Parse systemd timestamp
+            const nextDate = new Date(nextRun);
+            if (!isNaN(nextDate.getTime())) {
+                const now = new Date();
+                const hoursUntil = Math.round((nextDate.getTime() - now.getTime()) / (1000 * 60 * 60));
+                console.log(statusLine('Next Run', 'info', `${nextDate.toLocaleString()} (in ~${hoursUntil}h)`));
+            }
+        }
+        console.log(statusLine('Service', 'info', `${props.SubState ?? 'unknown'}`));
+        return;
+    }
+    catch {
+        // Not dnf-based
+    }
+    // Try apt-daily (Debian/Ubuntu)
+    try {
+        const { stdout } = await execa('systemctl', ['show', 'apt-daily-upgrade.timer', '--property=ActiveState,SubState,NextElapseUSecRealtime']);
+        const props = {};
+        for (const line of stdout.split('\n')) {
+            const [k, ...rest] = line.split('=');
+            if (k)
+                props[k.trim()] = rest.join('=').trim();
+        }
+        const active = props.ActiveState === 'active';
+        console.log(statusLine('Auto-Update Timer', active ? 'ok' : 'warn', active ? 'active (apt-daily)' : 'inactive'));
+        return;
+    }
+    catch {
+        // No systemd timers found
+    }
+    console.log(statusLine('OS Updates', 'info', 'automatic update timer not found'));
+}
+// ── show k8s status ──
+export async function showK8sStatus(_args, _opts, ctx) {
+    if (ctx.backend !== 'k8s') {
+        console.log(banner('Kubernetes Status'));
+        console.log(statusLine('Kubernetes', 'info', 'not using k8s backend'));
+        return;
+    }
+    const clear = showSpinner('Querying Kubernetes cluster...');
+    console.log(banner('Kubernetes Status'));
+    try {
+        const [{ stdout: nodeOut }, { stdout: podOut }] = await Promise.all([
+            execa('kubectl', ['get', 'nodes', '-o', 'json']),
+            execa('kubectl', ['get', 'pods', '-o', 'json']),
+        ]);
+        clear();
+        // Parse nodes
+        const nodes = JSON.parse(nodeOut);
+        if (nodes.items?.length > 0) {
+            console.log(chalk.bold('\n  Nodes'));
+            const nodeRows = nodes.items.map((n) => {
+                const name = n.metadata?.name ?? '';
+                const conditions = n.status?.conditions ?? [];
+                const ready = conditions.find((c) => c.type === 'Ready');
+                const isReady = ready?.status === 'True';
+                const stateStr = isReady
+                    ? `${Status.online.color(Status.online.symbol)} Ready`
+                    : `${Status.fail.color(Status.fail.symbol)} NotReady`;
+                const version = n.status?.nodeInfo?.kubeletVersion ?? '';
+                const os = n.status?.nodeInfo?.osImage ?? '';
+                return [name, stateStr, version, os];
+            });
+            console.log(table(['Name', 'Status', 'Version', 'OS'], nodeRows));
+        }
+        // Parse pods
+        const pods = JSON.parse(podOut);
+        if (pods.items?.length > 0) {
+            console.log(chalk.bold('\n  Pods'));
+            const podRows = pods.items.map((p) => {
+                const name = p.metadata?.name ?? '';
+                const phase = p.status?.phase ?? '';
+                let stateStr;
+                if (phase === 'Running') {
+                    stateStr = `${Status.online.color(Status.online.symbol)} Running`;
+                }
+                else if (phase === 'Succeeded') {
+                    stateStr = `${Status.ok.color(Status.ok.symbol)} Completed`;
+                }
+                else if (phase === 'Failed') {
+                    stateStr = `${Status.fail.color(Status.fail.symbol)} Failed`;
+                }
+                else if (phase === 'Pending') {
+                    stateStr = `${Status.waiting.color(Status.waiting.symbol)} Pending`;
+                }
+                else {
+                    stateStr = `${Status.info.color(Status.info.symbol)} ${phase}`;
+                }
+                const restarts = (p.status?.containerStatuses ?? [])
+                    .reduce((sum, c) => sum + (c.restartCount ?? 0), 0);
+                const restartsStr = restarts > 0 ? chalk.yellow(`${restarts}`) : chalk.dim('0');
+                const ns = p.metadata?.namespace ?? '';
+                return [name, ns, stateStr, restartsStr];
+            });
+            console.log(table(['Pod', 'Namespace', 'Status', 'Restarts'], podRows));
+        }
+    }
+    catch (err) {
+        clear();
+        console.log(statusLine('Kubernetes', 'fail', err.message));
+    }
+}
+//# sourceMappingURL=show.js.map