pyre-cli 6.0.0 → 6.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "CLI Mac monitoring tool: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",

package/src/completions.ts

@@ -0,0 +1,118 @@
+export function generateZshCompletions(): string {
+  return `#compdef pyre
+
+_pyre() {
+    local -a commands
+    commands=(
+        'live:Start interactive live monitoring dashboard'
+        'info:Display static system overview'
+        'doctor:Run system permissions and diagnostic checks'
+        'web:Launch web dashboard server'
+        'config:Show or reset configuration options'
+        'p2p:P2P streaming server or client'
+        'ssh:Stream metrics over SSH'
+        'bench:Benchmark command while logging system stats'
+        'completions:Generate shell completion scripts'
+    )
+
+    _arguments -s \\
+        '(-j --json)'{-j,--json}'[Output snapshot as JSON]' \\
+        '--html[Output snapshot as HTML]' \\
+        '--md[Output snapshot as Markdown]' \\
+        '(-c --csv)'{-c,--csv}'[Output snapshot as CSV]' \\
+        '(-t --tsv)'{-t,--tsv}'[Output snapshot as TSV]' \\
+        '--detailed[Include detailed system info and sensor readings]' \\
+        '--theme[Default theme]:theme:(default dracula cyberpunk monochrome nord gruvbox)' \\
+        '--interval[Refresh interval in seconds]:seconds:' \\
+        '--once[Show a single static snapshot]' \\
+        '--out[Write snapshot output to file]:file:_files' \\
+        '--export-dir[Directory for snapshot exports and logs]:directory:_files -/' \\
+        '--log[Start continuous CSV logging]' \\
+        '--tree[Show process tree view]' \\
+        '--sort[Sort processes by]:key:(cpu mem pid user command state threads runtime)' \\
+        '--packets[Include packet monitor panel]' \\
+        '--limit[Max processes to include]:count:' \\
+        '--alert-cpu[CPU alert threshold pct]:pct:' \\
+        '--alert-temp[CPU alert threshold temp C]:temp:' \\
+        '--temp-unit[Temperature display unit]:unit:(c f)' \\
+        '*::command:->command'
+
+    case $state in
+        command)
+            _describe -t commands 'pyre command' commands
+            ;;
+    esac
+}
+
+_pyre "$@"
+`;
+}
+
+export function generateBashCompletions(): string {
+  return `# bash completion for pyre
+
+_pyre_completions() {
+    local cur prev opts commands
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    commands="live info doctor web config p2p ssh bench completions"
+    opts="--json --html --md --csv --tsv --detailed --theme --interval --once --out --export-dir --log --tree --sort --packets --limit --alert-cpu --alert-temp --temp-unit"
+
+    case "\${prev}" in
+        --theme)
+            COMPREPLY=( $(compgen -W "default dracula cyberpunk monochrome nord gruvbox" -- \${cur}) )
+            return 0
+            ;;
+        --sort)
+            COMPREPLY=( $(compgen -W "cpu mem pid user command state threads runtime" -- \${cur}) )
+            return 0
+            ;;
+        --temp-unit)
+            COMPREPLY=( $(compgen -W "c f" -- \${cur}) )
+            return 0
+            ;;
+        config)
+            COMPREPLY=( $(compgen -W "show reset" -- \${cur}) )
+            return 0
+            ;;
+        p2p)
+            COMPREPLY=( $(compgen -W "server connect" -- \${cur}) )
+            return 0
+            ;;
+    esac
+
+    if [[ \${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+
+    COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+}
+
+complete -F _pyre_completions pyre
+`;
+}
+
+export function generateFishCompletions(): string {
+  return `# fish completion for pyre
+
+complete -c pyre -n "__fish_use_subcommand" -a live -d "Start interactive live monitoring dashboard"
+complete -c pyre -n "__fish_use_subcommand" -a info -d "Display static system overview"
+complete -c pyre -n "__fish_use_subcommand" -a doctor -d "Run system diagnostics"
+complete -c pyre -n "__fish_use_subcommand" -a web -d "Launch web dashboard server"
+complete -c pyre -n "__fish_use_subcommand" -a config -d "Show or reset configuration options"
+complete -c pyre -n "__fish_use_subcommand" -a p2p -d "P2P streaming mode"
+complete -c pyre -n "__fish_use_subcommand" -a completions -d "Generate shell completions"
+
+complete -c pyre -l json -s j -d "Output snapshot as JSON"
+complete -c pyre -l html -d "Output snapshot as HTML"
+complete -c pyre -l md -d "Output snapshot as Markdown"
+complete -c pyre -l csv -s c -d "Output snapshot as CSV"
+complete -c pyre -l tsv -s t -d "Output snapshot as TSV"
+complete -c pyre -l detailed -d "Include detailed system info and sensor readings"
+complete -c pyre -l theme -x -a "default dracula cyberpunk monochrome nord gruvbox" -d "Set color theme"
+complete -c pyre -l sort -x -a "cpu mem pid user command state threads runtime" -d "Sort processes by key"
+complete -c pyre -l temp-unit -x -a "c f" -d "Temperature unit"
+`;
+}

package/src/diffCmd.ts

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import chalk from 'chalk';
+import type { StatsData } from './monitors/types.js';
+
+export function runDiffCommand(file1: string, file2: string): void {
+  console.log(chalk.bold(`\n  pyre diff — Snapshot Comparison\n`));
+  console.log(chalk.dim(`  Snapshot A: ${file1}`));
+  console.log(chalk.dim(`  Snapshot B: ${file2}\n`));
+
+  try {
+    const dataA: StatsData = JSON.parse(fs.readFileSync(file1, 'utf-8'));
+    const dataB: StatsData = JSON.parse(fs.readFileSync(file2, 'utf-8'));
+
+    const diffNum = (label: string, valA: number, valB: number, unit = '') => {
+      const delta = valB - valA;
+      const sign = delta > 0 ? '+' : '';
+      const color = delta > 0 ? chalk.red : delta < 0 ? chalk.green : chalk.dim;
+      console.log(`  ${label.padEnd(20)} ${valA.toFixed(1)}${unit} ➔ ${valB.toFixed(1)}${unit} (${color(sign + delta.toFixed(1) + unit)})`);
+    };
+
+    diffNum('CPU Usage', dataA.cpu.usage, dataB.cpu.usage, '%');
+    diffNum('Memory Usage', dataA.memory.usagePercent, dataB.memory.usagePercent, '%');
+    if (dataA.cpu.temperature && dataB.cpu.temperature) {
+      diffNum('CPU Temp', dataA.cpu.temperature, dataB.cpu.temperature, '°C');
+    }
+    if (dataA.gpu && dataB.gpu) {
+      diffNum('GPU Util', dataA.gpu.utilization, dataB.gpu.utilization, '%');
+    }
+    diffNum('Network RX Packets', dataA.network.rxPackets, dataB.network.rxPackets);
+    diffNum('Network TX Packets', dataA.network.txPackets, dataB.network.txPackets);
+
+    console.log();
+  } catch (err: any) {
+    console.log(chalk.red(`Failed to compare snapshots: ${err.message}`));
+  }
+}

package/src/doctor.ts

@@ -0,0 +1,123 @@
+import chalk from 'chalk';
+import { run } from './monitors/run.js';
+import { readConfig, CONFIG_FILE } from './state/config.js';
+
+export interface DoctorCheck {
+  name: string;
+  status: 'ok' | 'warn' | 'error';
+  message: string;
+  details?: string;
+}
+
+export async function runDoctor(): Promise<DoctorCheck[]> {
+  const checks: DoctorCheck[] = [];
+
+  // 1. Sudo / Powermetrics Access
+  try {
+    const pmResult = await run('sudo -n powermetrics --samplers cpu_power -n 1 2>&1', '');
+    if (pmResult.includes('Password:') || pmResult.includes('Permission denied') || pmResult.includes('sudo: a password is required')) {
+      checks.push({
+        name: 'Sudo / Powermetrics',
+        status: 'warn',
+        message: 'Passwordless sudo for powermetrics is not configured.',
+        details: 'Powermetrics allows high-precision GPU & CPU power sampling. Run with sudo or configure passwordless sudo in /etc/sudoers.',
+      });
+    } else {
+      checks.push({
+        name: 'Sudo / Powermetrics',
+        status: 'ok',
+        message: 'Powermetrics access available.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Sudo / Powermetrics',
+      status: 'warn',
+      message: 'Powermetrics check failed.',
+    });
+  }
+
+  // 2. TCC / System Permissions
+  try {
+    const psCheck = await run('ps -ax -o pid,user,command', '');
+    if (psCheck.length > 0) {
+      checks.push({
+        name: 'TCC / Process Visibility',
+        status: 'ok',
+        message: 'Process listing access available.',
+      });
+    } else {
+      checks.push({
+        name: 'TCC / Process Visibility',
+        status: 'warn',
+        message: 'Restricted process visibility.',
+        details: 'Grant Full Disk Access or Terminal permissions in System Settings -> Privacy & Security.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'TCC / Process Visibility',
+      status: 'error',
+      message: 'Unable to list system processes.',
+    });
+  }
+
+  // 3. Network Reachability for P2P
+  try {
+    const netCheck = await run('netstat -rn', '');
+    if (netCheck.includes('default') || netCheck.includes('gateway')) {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'ok',
+        message: 'Network interface active with default gateway.',
+      });
+    } else {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'warn',
+        message: 'No active network route detected for P2P mode.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Network Reachability',
+      status: 'warn',
+      message: 'Could not verify network routes.',
+    });
+  }
+
+  // 4. Config file integrity
+  try {
+    const cfg = readConfig();
+    checks.push({
+      name: 'Configuration File',
+      status: 'ok',
+      message: `Config file valid (${CONFIG_FILE}).`,
+    });
+  } catch (err: any) {
+    checks.push({
+      name: 'Configuration File',
+      status: 'error',
+      message: 'Failed to parse config file.',
+      details: err.message,
+    });
+  }
+
+  return checks;
+}
+
+export function printDoctorReport(checks: DoctorCheck[]): void {
+  console.log(chalk.bold('\n  pyre doctor — System Diagnostics\n'));
+
+  for (const check of checks) {
+    let icon = chalk.green('✔');
+    if (check.status === 'warn') icon = chalk.yellow('⚠');
+    if (check.status === 'error') icon = chalk.red('✖');
+
+    console.log(`  ${icon} ${chalk.bold(check.name.padEnd(26))} ${check.message}`);
+    if (check.details) {
+      console.log(chalk.dim(`     ↳ ${check.details}`));
+    }
+  }
+  console.log();
+}

package/src/formatters/render.ts

@@ -714,7 +714,7 @@ function btopCpuBox(data: StatsData, width: number, theme: ThemeColors, opts: Ta
     if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
       const coreColW = Math.floor((rightW - 1) / 2);
       const half = Math.ceil(data.cpu.coreUsage.length / 2);
-      for (let i = 0; i < Math.min(2, half); i++) {
+      for (let i = 0; i < half; i++) {
         const u1 = data.cpu.coreUsage[i];
         const u2 = data.cpu.coreUsage[i + half];
         const c1BarW = Math.max(3, coreColW - 8);
@@ -763,9 +763,18 @@ function btopLeftColumn(data: StatsData, width: number, theme: ThemeColors, opts
     for (const d of data.disk.slice(0, 2)) {
       const capNum = parseInt(d.capacity, 10) || 0;
       const mountShort = truncatePlain(d.mountpoint, 8);
-      diskLines.push(`${mountShort} ${d.used}/${d.size} [${gaugeBar(capNum, Math.max(3, contentWidth - 18))}] ${d.capacity}`);
+      let ioStr = '';
+      if (d.readBytesSec !== undefined || d.writeBytesSec !== undefined) {
+        const rStr = formatBytes(d.readBytesSec || 0);
+        const wStr = formatBytes(d.writeBytesSec || 0);
+        ioStr = ` R:${rStr}/s W:${wStr}/s`;
+      }
+      diskLines.push(`${mountShort} ${d.used}/${d.size} [${gaugeBar(capNum, Math.max(3, contentWidth - 18 - ioStr.length))}] ${d.capacity}${ioStr}`);
     }
-    out.push(...panel('0 disk io', diskLines, width, theme.disk, theme.border, diskLines.length));
+    const totalRead = data.disk.reduce((acc, d) => acc + (d.readBytesSec || 0), 0);
+    const totalWrite = data.disk.reduce((acc, d) => acc + (d.writeBytesSec || 0), 0);
+    const diskHeaderRight = `R:${formatBytes(totalRead)}/s W:${formatBytes(totalWrite)}/s`;
+    out.push(...panel('0 disk io', diskLines, width, theme.disk, theme.border, diskLines.length, diskHeaderRight));
   }
 
   // --- Box 3: 7 net ---

package/src/formatters/themes.ts

@@ -8,7 +8,11 @@
  */
 import chalk from 'chalk';
 
-export type ThemeName = 'default' | 'dracula' | 'cyberpunk' | 'monochrome' | 'nord' | 'gruvbox';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export type ThemeName = string;
 
 export interface ThemeColors {
    border: (s: string) => string;
@@ -24,16 +28,7 @@ export interface ThemeColors {
    process: (s: string) => string;
 }
 
-/**
- * Built-in colour themes.
- *
- * - **default** — muted greys and cyan accents, safe for any terminal.
- * - **dracula**  — the popular Dracula dark palette.
- * - **cyberpunk** — high-contrast neon on black.
- * - **monochrome** — white-only, useful for colour-blind users or
- *   terminals without 256-colour support.
- */
-export const THEMES: Record<ThemeName, ThemeColors> = {
+export const BUILTIN_THEMES: Record<string, ThemeColors> = {
    default: {
      border: chalk.hex('#4b5563'),
      cpu: chalk.hex('#22d3ee'),
@@ -112,4 +107,44 @@ export const THEMES: Record<ThemeName, ThemeColors> = {
       graphs: chalk.hex('#fb4934'),
       process: chalk.hex('#ebdbb2'),
     },
-  };
+  };
+
+export function loadCustomThemes(): Record<string, ThemeColors> {
+  const themes = { ...BUILTIN_THEMES };
+  const themesDir = path.join(os.homedir(), '.config', 'pyre', 'themes');
+  try {
+    if (fs.existsSync(themesDir)) {
+      const files = fs.readdirSync(themesDir);
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const name = path.basename(file, '.json');
+          try {
+            const raw = fs.readFileSync(path.join(themesDir, file), 'utf-8');
+            const data = JSON.parse(raw);
+            const buildColor = (val?: string) => (val ? (val.startsWith('#') ? chalk.hex(val) : (chalk as any)[val] || chalk.white) : chalk.white);
+            themes[name] = {
+              border: buildColor(data.border),
+              cpu: buildColor(data.cpu),
+              mem: buildColor(data.mem),
+              gpu: buildColor(data.gpu),
+              power: buildColor(data.power),
+              battery: buildColor(data.battery),
+              thermal: buildColor(data.thermal),
+              network: buildColor(data.network),
+              disk: buildColor(data.disk),
+              graphs: buildColor(data.graphs),
+              process: buildColor(data.process),
+            };
+          } catch {
+            // ignore bad theme file
+          }
+        }
+      }
+    }
+  } catch {
+    // ignore directory read error
+  }
+  return themes;
+}
+
+export const THEMES: Record<string, ThemeColors> = loadCustomThemes();

package/src/historyCmd.ts

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { sparkline } from './sparkline.js';
+
+export interface HistoryOptions {
+  days?: number;
+  dir?: string;
+}
+
+export function runHistoryCommand(opts: HistoryOptions = {}): void {
+  const days = opts.days || 7;
+  const dir = opts.dir || './pyre-exports';
+
+  console.log(chalk.bold(`\n  pyre history — Past ${days} Days Trend\n`));
+
+  if (!fs.existsSync(dir)) {
+    console.log(chalk.yellow(`  No logs directory found at ${dir}`));
+    return;
+  }
+
+  const files = fs.readdirSync(dir).filter(f => f.startsWith('pyre-log-') && f.endsWith('.csv'));
+  if (files.length === 0) {
+    console.log(chalk.yellow(`  No CSV logs found in ${dir}`));
+    return;
+  }
+
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+  const cpuPoints: number[] = [];
+  const memPoints: number[] = [];
+  const tempPoints: number[] = [];
+
+  for (const file of files.sort()) {
+    const fullPath = path.join(dir, file);
+    try {
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      const lines = content.split('\n').slice(1);
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const parts = line.split(',');
+        if (parts.length >= 4) {
+          const tsStr = parts[0];
+          const ts = new Date(tsStr).getTime();
+          if (!isNaN(ts) && ts >= cutoff) {
+            const cpu = parseFloat(parts[1]);
+            const mem = parseFloat(parts[2]);
+            const temp = parseFloat(parts[3]);
+            if (!isNaN(cpu)) cpuPoints.push(cpu);
+            if (!isNaN(mem)) memPoints.push(mem);
+            if (!isNaN(temp)) tempPoints.push(temp);
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  if (cpuPoints.length === 0) {
+    console.log(chalk.yellow(`  No historical entries recorded within the last ${days} days.`));
+    return;
+  }
+
+  console.log(`  Data Points: ${cpuPoints.length} logged snapshots`);
+  console.log(`  CPU Usage:   ${sparkline(cpuPoints, { min: 0, max: 100 })} (${(cpuPoints.reduce((a, b) => a + b, 0) / cpuPoints.length).toFixed(1)}% avg)`);
+  console.log(`  Memory:      ${sparkline(memPoints, { min: 0, max: 100 })} (${(memPoints.reduce((a, b) => a + b, 0) / memPoints.length).toFixed(1)}% avg)`);
+  if (tempPoints.length) {
+    console.log(`  Temperature: ${sparkline(tempPoints)} (${(tempPoints.reduce((a, b) => a + b, 0) / tempPoints.length).toFixed(1)}°C avg)`);
+  }
+  console.log();
+}

package/src/index.ts

@@ -17,8 +17,11 @@ import { formatTable, formatJson, formatCsv, formatTsv, formatHtml, formatMarkdo
 import { startLive, stopLive } from './live/index.js';
 import { showSplash } from './splash.js';
 import { P2PServer, P2PClient } from './p2p/index.js';
-import { readConfig } from './state/config.js';
-import { CONFIG_FILE } from './state/config.js';
+import { runDoctor, printDoctorReport } from './doctor.js';
+import { generateZshCompletions, generateBashCompletions, generateFishCompletions } from './completions.js';
+import { runHistoryCommand } from './historyCmd.js';
+import { runDiffCommand } from './diffCmd.js';
+import { readConfig, CONFIG_FILE } from './state/config.js';
 
 const config = readConfig();
 
@@ -62,7 +65,10 @@ program
     .option('--p2p-deny <ips>', 'Comma-separated list of denied IPs')
     .option('--p2p-audit-log <dir>', 'Directory for P2P audit logs')
     .option('--p2p-hmac-key <key>', 'HMAC key for message signing (default: derived from password)')
-    .option('--port <port>', 'Port number for web server mode', '3000');
+    .option('--port <port>', 'Port number for web server mode', '3000')
+    .option('--web-auth', 'Enable Basic Authentication for web server')
+    .option('--web-user <user>', 'Username for web server authentication', 'admin')
+    .option('--web-pass <pass>', 'Password for web server authentication', 'pyre');
 
 program.parse(process.argv);
 
@@ -123,8 +129,21 @@ async function runServerCommand(): Promise<void> {
 async function main() {
   const cmd = program.args[0];
 
-  if (cmd === 'info') {
-    await runInfoCommand();
+  if (cmd === 'history') {
+    const daysIdx = program.args.indexOf('--days');
+    const days = daysIdx !== -1 ? parseInt(program.args[daysIdx + 1], 10) || 7 : 7;
+    runHistoryCommand({ days });
+    return;
+  }
+
+  if (cmd === 'diff') {
+    const file1 = program.args[1];
+    const file2 = program.args[2];
+    if (!file1 || !file2) {
+      console.log(chalk.red('Usage: pyre diff <snapshot1.json> <snapshot2.json>'));
+      process.exit(1);
+    }
+    runDiffCommand(file1, file2);
     return;
   }
 
@@ -491,9 +510,71 @@ async function runSshCommand(host: string): Promise<void> {
 async function runWebCommand(): Promise<void> {
   const http = await import('node:http');
   const port = parseInt(opts.port || process.env.PORT || '3000', 10) || 3000;
+  const authEnabled = !!opts.webAuth;
+  const authUser = opts.webUser || 'admin';
+  const authPass = opts.webPass || 'pyre';
 
   const server = http.createServer(async (req, res) => {
+    // 1. Basic Authentication Check
+    if (authEnabled) {
+      const authHeader = req.headers.authorization;
+      if (!authHeader || !authHeader.startsWith('Basic ')) {
+        res.writeHead(401, {
+          'WWW-Authenticate': 'Basic realm="pyre Web Dashboard"',
+          'Content-Type': 'text/plain',
+        });
+        res.end('401 Unauthorized');
+        return;
+      }
+      const credentials = Buffer.from(authHeader.split(' ')[1], 'base64').toString('utf-8');
+      const [user, pass] = credentials.split(':');
+      if (user !== authUser || pass !== authPass) {
+        res.writeHead(401, {
+          'WWW-Authenticate': 'Basic realm="pyre Web Dashboard"',
+          'Content-Type': 'text/plain',
+        });
+        res.end('401 Unauthorized');
+        return;
+      }
+    }
+
     const url = req.url || '/';
+
+    // 2. Health check endpoint
+    if (url === '/health' || url === '/api/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'ok', uptime: process.uptime(), timestamp: new Date().toISOString() }));
+      return;
+    }
+
+    // 3. Real-time Server-Sent Events (SSE) stream endpoint
+    if (url === '/api/stream') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+      });
+
+      const sendStats = async () => {
+        try {
+          const data = await collectAll({ detailed: true });
+          res.write(`data: ${JSON.stringify(data)}\n\n`);
+        } catch {
+          // ignore stream collect error
+        }
+      };
+
+      sendStats();
+      const intervalId = setInterval(sendStats, 2000);
+
+      req.on('close', () => {
+        clearInterval(intervalId);
+      });
+      return;
+    }
+
+    // 4. Static HTML dashboard & API snapshot endpoints
     if (url === '/' || url === '/index.html') {
       res.writeHead(200, { 'Content-Type': 'text/html' });
       const indexPath = path.join(process.cwd(), 'index.html');
@@ -523,6 +604,10 @@ async function runWebCommand(): Promise<void> {
     console.log(chalk.bold(`\n  pyre web server running on port ${port}`));
     console.log(chalk.dim(`  Dashboard: http://0.0.0.0:${port}/`));
     console.log(chalk.dim(`  API:       http://0.0.0.0:${port}/api`));
+    console.log(chalk.dim(`  SSE Stream: http://0.0.0.0:${port}/api/stream`));
+    if (authEnabled) {
+      console.log(chalk.yellow(`  Authentication: Enabled (${authUser}:${authPass})`));
+    }
     console.log(chalk.dim('  Press Ctrl+C to stop\n'));
   });
 

package/src/live/input.ts

@@ -189,12 +189,20 @@ function handleInputModeKey(str: string, key: readline.Key) {
 
    if (key.name === 'backspace') {
      state.inputBuffer = state.inputBuffer.slice(0, -1);
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer;
+       invalidateTableCache();
+     }
      render();
      return;
    }
 
    if (str && str.length === 1 && !key.ctrl && !key.meta) {
      state.inputBuffer += str;
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer;
+       invalidateTableCache();
+     }
      render();
    }
  }