pyre-cli 1.3.0 → 2.0.0

package/src/live/input.ts

@@ -0,0 +1,443 @@
+/**
+ * Live dashboard input handling and session lifecycle.
+ *
+ * Contains `startLive`, `stopLive`, the keypress handler,
+ * resize handling, and the ticker restart logic.
+ *
+ * Imported by `index.ts` as the public API of the live module.
+ */
+import readline from 'node:readline';
+import chalk from 'chalk';
+import { collectAll, StatsData } from '../monitors/index.js';
+import { THEMES, type ThemeName, type VisibleItems, getTabHitboxes, TAB_BAR_ROW } from '../formatters/index.js';
+import { state, setStatus } from './state.js';
+import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow } from './export.js';
+import { render, footerLine, checkAlerts, processRowBudget } from './render.js';
+import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
+
+function handleInputModeKey(str: string, key: readline.Key) {
+   if (key.name === 'escape') {
+     state.inputMode = null;
+     state.inputBuffer = '';
+     render();
+     return;
+   }
+
+   if (state.inputMode === 'customizer') {
+     const themesList = Object.keys(THEMES) as ThemeName[];
+
+     if (key.name === 'up' || str === 'k') {
+       state.customizerIndex = (state.customizerIndex - 1 + state.CUSTOMIZER_OPTIONS.length) % state.CUSTOMIZER_OPTIONS.length;
+     } else if (key.name === 'down' || str === 'j') {
+       state.customizerIndex = (state.customizerIndex + 1) % state.CUSTOMIZER_OPTIONS.length;
+     } else if (key.name === 'return' || str === ' ') {
+       const selected = state.CUSTOMIZER_OPTIONS[state.customizerIndex];
+       if (selected === 'Theme') {
+         const nextIdx = (themesList.indexOf(state.currentTheme) + 1) % themesList.length;
+         state.currentTheme = themesList[nextIdx];
+        } else if (selected === 'Toggle Tree View') {
+          state.treeView = !state.treeView;
+        } else if (selected === 'Graph Mode') {
+          state.graphMode = state.graphMode === 'spark' ? 'bar' : 'spark';
+        } else {
+
+         const itemKey = selected.replace('Toggle ', '').toLowerCase() as keyof VisibleItems;
+         state.visiblePanels[itemKey] = !state.visiblePanels[itemKey];
+       }
+     }
+     render();
+     return;
+   }
+
+    if (state.inputMode === 'signal') {
+      if (key.name === 'up' || str === 'k') {
+       const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
+       state.inputBuffer = state.SIGNAL_OPTIONS[(idx - 1 + state.SIGNAL_OPTIONS.length) % state.SIGNAL_OPTIONS.length];
+      } else if (key.name === 'down' || str === 'j') {
+       const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
+       state.inputBuffer = state.SIGNAL_OPTIONS[(idx + 1) % state.SIGNAL_OPTIONS.length];
+      } else if (key.name === 'return' || str === ' ') {
+        killProcess(state.inputBuffer.trim(), state.inputBuffer.trim() as NodeJS.Signals);
+        state.inputMode = null;
+        state.inputBuffer = '';
+        render();
+        return;
+      }
+      render();
+      return;
+    }
+
+   if (key.name === 'return') {
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer.trim();
+       setStatus(state.processFilter ? `Filtering: "${state.processFilter}"` : 'Filter cleared');
+     } else if (state.inputMode === 'kill') {
+       killProcess(state.inputBuffer.trim());
+     }
+     state.inputMode = null;
+     state.inputBuffer = '';
+     render();
+     return;
+   }
+
+   if (key.name === 'backspace') {
+     state.inputBuffer = state.inputBuffer.slice(0, -1);
+     render();
+     return;
+   }
+
+   if (str && str.length === 1 && !key.ctrl && !key.meta) {
+     state.inputBuffer += str;
+     render();
+   }
+ }
+
+function killProcess(pidStr: string, signal: string = 'SIGTERM') {
+   const pid = parseInt(pidStr, 10);
+   if (!pid || pid <= 0) {
+     setStatus(`Invalid PID: ${pidStr}`);
+     return;
+   }
+   try {
+     process.kill(pid, signal as NodeJS.Signals);
+     setStatus(`Sent ${signal} to PID ${pid}`);
+   } catch (err: any) {
+     setStatus(`Failed to send ${signal} to ${pid}: ${err.message}`);
+   }
+  }
+
+  function onResize() {
+   state.termWidth = process.stdout.columns || 80;
+   state.termHeight = process.stdout.rows || 24;
+   state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
+   render();
+ }
+
+ function restartTicker() {
+   if (state.intervalHandle) clearInterval(state.intervalHandle);
+   state.intervalHandle = setInterval(tick, state.interval * 1000);
+ }
+
+  async function tick() {
+    if (state.paused) return;
+    try {
+      const data = await collectAll({ detailed: state.detailed, processLimit: processRowBudget() });
+      state.lastData = data;
+
+      const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+      state.history.push({
+        cpuUsage: data.cpu.usage,
+        memUsage: data.memory.usagePercent,
+        temp,
+        rxBytes: data.network.rxBytes,
+        txBytes: data.network.txBytes,
+        gpuUtil: data.gpu?.utilization,
+        powerWatts: data.power?.combinedWatts ?? data.power?.cpuWatts ?? 0,
+        rxPackets: data.network.rxPackets,
+        txPackets: data.network.txPackets,
+        connections: data.network.connections ?? 0,
+      });
+
+      writeLogRow(data);
+      checkAlerts(data);
+      render();
+    } catch {
+      // skip bad tick
+    }
+  }
+
+ /**
+  * Start the interactive live dashboard.
+  *
+  * Sets up raw TTY mode, keypress listeners, and the
+  * rendering interval.  Idempotent — calling while already
+  * running is a no-op.
+  */
+  export async function startLive(opts: LiveOptions) {
+    if (state.running) return;
+    state.running = true;
+    state.paused = false;
+    state.detailed = !!opts.detailed;
+    state.interval = opts.interval;
+    if (opts.exportDir) state.exportDir = opts.exportDir;
+    state.termWidth = process.stdout.columns || 80;
+    state.termHeight = process.stdout.rows || 24;
+    state.history.reset();
+    state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
+
+    process.stdout.write('\x1b[?1049h');
+    process.stdout.write('\x1b[?25l');
+    process.stdout.write('\x1b[2J\x1b[H');
+    process.title = 'pyre';
+
+    if (state.mouseEnabled) {
+      process.stdout.write('\x1b[?1000h');
+    }
+
+    await tick();
+    restartTicker();
+
+    if (opts.autoLog) startLogging();
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    process.stdout.on('resize', onResize);
+
+    state.keypressHandler = (str: string, key: readline.Key) => {
+      if (!key) return;
+
+      if (key.ctrl && key.name === 'c') {
+        stopLive();
+        return;
+      }
+
+      if (state.inputMode) {
+        handleInputModeKey(str, key);
+        return;
+      }
+
+      if (key.mouse) {
+        handleMouseClick(key.mouse);
+        return;
+      }
+
+      if (key.sequence && key.sequence.startsWith('\x1b[M')) {
+        handleNormalMouse(key.sequence);
+        return;
+      }
+
+      if (key.sequence && key.sequence.startsWith('\x1b[<')) {
+        handleSGRMouse(key.sequence);
+        return;
+      }
+
+      switch (key.sequence) {
+        case '+':
+          state.interval += 1;
+          restartTicker();
+          setStatus(`Interval set to ${state.interval}s`);
+          return;
+        case '-':
+          state.interval = Math.max(1, state.interval - 1);
+          restartTicker();
+          setStatus(`Interval set to ${state.interval}s`);
+          return;
+        case '/':
+          state.inputMode = 'filter';
+          state.inputBuffer = state.processFilter;
+          render();
+          return;
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9': {
+          const tabMap: Record<string, string> = {
+            '0': 'disk', '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power',
+            '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks'
+          };
+          const panelId = tabMap[key.sequence];
+          if (panelId) {
+            state.activePanel = state.activePanel === panelId ? 'grid' : panelId;
+            setStatus(state.activePanel === 'grid' ? 'Grid view' : `${panelId} panel`);
+            render();
+          }
+          return;
+        }
+        case 'P': {
+          state.activePanel = state.activePanel === 'process' ? 'grid' : 'process';
+          setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Process panel');
+          render();
+          return;
+        }
+      }
+
+      switch (key.name) {
+        case 'q':
+          stopLive();
+          break;
+        case 'left': {
+          const currentIdx = state.PANEL_TABS.findIndex(t => t.id === state.activePanel);
+          if (currentIdx > 0) {
+            state.activePanel = state.PANEL_TABS[currentIdx - 1].id;
+          } else if (currentIdx === -1) {
+            state.activePanel = state.PANEL_TABS[state.PANEL_TABS.length - 1].id;
+          }
+          setStatus(`Panel: ${state.activePanel}`);
+          render();
+          break;
+        }
+        case 'right': {
+          const currentIdx = state.PANEL_TABS.findIndex(t => t.id === state.activePanel);
+          if (currentIdx < state.PANEL_TABS.length - 1) {
+            state.activePanel = state.PANEL_TABS[currentIdx + 1].id;
+          } else if (currentIdx === -1) {
+            state.activePanel = state.PANEL_TABS[0].id;
+          }
+          setStatus(`Panel: ${state.activePanel}`);
+          render();
+          break;
+        }
+        case 'c':
+          state.inputMode = 'customizer';
+          state.customizerIndex = 0;
+          render();
+          break;
+        case 'p':
+          state.paused = !state.paused;
+          setStatus(state.paused ? 'Paused' : 'Resumed');
+          render();
+          break;
+         case 'g':
+           state.showGraphs = !state.showGraphs;
+           render();
+           break;
+         case 'b':
+           state.graphMode = state.graphMode === 'spark' ? 'bar' : 'spark';
+           setStatus(`Graph mode: ${state.graphMode}`);
+           render();
+           break;
+         case 'd':
+
+          state.detailed = !state.detailed;
+          setStatus(`Detailed sensor mode: ${state.detailed ? 'on' : 'off'}`);
+          break;
+        case 's':
+          const sortCycle: SortMode[] = ['cpu', 'mem', 'pid', 'user', 'command', 'state', 'threads', 'runtime'];
+          const curIdx = sortCycle.indexOf(state.sortMode);
+          state.sortMode = sortCycle[(curIdx + 1) % sortCycle.length];
+          setStatus(`Sorting by ${state.sortMode}`);
+          render();
+          break;
+        case 'k':
+          state.inputMode = 'kill';
+          state.inputBuffer = '';
+          render();
+          break;
+        case 'S':
+          state.inputMode = 'signal';
+          state.inputBuffer = 'SIGTERM';
+          render();
+          break;
+        case 't':
+          state.treeView = !state.treeView;
+          setStatus(state.treeView ? 'Tree view enabled' : 'Flat view enabled');
+          render();
+          break;
+        case 'e':
+          exportSnapshot();
+          render();
+          break;
+        case 'l':
+          toggleLogging();
+          render();
+          break;
+        case 'f':
+          state.exportFormat = state.exportFormat === 'json' ? 'csv' : state.exportFormat === 'csv' ? 'tsv' : 'json';
+          setStatus(`Export format: ${state.exportFormat}`);
+          render();
+          break;
+        case 'tab':
+          cycleTab(1);
+          break;
+        case 'left':
+          cycleTab(-1);
+          break;
+        case 'right':
+          cycleTab(1);
+          break;
+        default:
+          if (str && str.length === 1) {
+            const tabId = tabKeyToId(str);
+            if (tabId) {
+              state.activePanel = tabId;
+              setStatus(`Panel: ${tabId.toUpperCase()}`);
+              render();
+            }
+          }
+      }
+    };
+
+    process.stdin.on('keypress', state.keypressHandler);
+    process.once('SIGINT', () => stopLive());
+  }
+
+  function tabKeyToId(str: string): string | null {
+    const map: Record<string, string> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process' };
+    return map[str] ?? null;
+  }
+
+  function cycleTab(direction: number) {
+    const tabs = state.PANEL_TABS.map(t => t.id);
+    const current = state.activePanel === 'grid' ? -1 : tabs.indexOf(state.activePanel);
+    const next = (current + direction + tabs.length) % tabs.length;
+    state.activePanel = tabs[next];
+    setStatus(`Panel: ${state.activePanel.toUpperCase()}`);
+    render();
+  }
+
+  function handleNormalMouse(seq: string) {
+    if (seq.length < 6) return;
+    const cb = seq.charCodeAt(3) - 32;
+    const cx = seq.charCodeAt(4) - 32;
+    const cy = seq.charCodeAt(5) - 32;
+    if (cb === 0 || cb === 1) {
+      handleMouseClick(cy, cx);
+    }
+  }
+
+  function handleSGRMouse(seq: string) {
+    const match = seq.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+    if (!match) return;
+    const button = parseInt(match[1]);
+    const cx = parseInt(match[2]);
+    const cy = parseInt(match[3]);
+    if (button === 0 || button === 1) {
+      handleMouseClick(cy, cx);
+    }
+  }
+
+  function handleMouseClick(y: number, x: number) {
+    if (y !== TAB_BAR_ROW) return;
+    const hitboxes = getTabHitboxes();
+    const hit = hitboxes.find(h => x >= h.start && x < h.end);
+    if (hit) {
+      state.activePanel = state.activePanel === hit.id ? 'grid' : (hit.id as typeof state.activePanel);
+      setStatus(state.activePanel === 'grid' ? 'Grid view' : `Panel: ${hit.id.toUpperCase()}`);
+      render();
+    }
+  }
+
+  export function stopLive() {
+    if (state.intervalHandle) {
+      clearInterval(state.intervalHandle);
+      state.intervalHandle = null;
+    }
+    if (state.statusTimer) {
+      clearTimeout(state.statusTimer);
+      state.statusTimer = null;
+    }
+    if (state.logStream) {
+      state.logStream.end();
+      state.logStream = null;
+    }
+    if (state.keypressHandler) {
+      process.stdin.removeListener('keypress', state.keypressHandler);
+      state.keypressHandler = null;
+    }
+    process.stdout.removeListener('resize', onResize);
+
+    state.running = false;
+    state.logging = false;
+
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+
+    if (state.mouseEnabled) {
+      process.stdout.write('\x1b[?1000l');
+    }
+    process.stdout.write('\x1b[?25h');
+    process.stdout.write('\x1b[?1049l');
+    process.stdout.write('\x1b[2J\x1b[H');
+
+    process.exit(0);
+  }

package/src/live/render.ts

@@ -0,0 +1,146 @@
+/**
+ * Live dashboard rendering.
+ *
+ * Contains the main `render` loop, the footer key-bindings
+ * line, the UI customizer overlay, and the thermal/CPU
+ * alert checker.  All state variables are imported from
+ * `state.ts`.
+ */
+import chalk from 'chalk';
+import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName } from '../formatters/index.js';
+import { state, setStatus, SIGNAL_OPTIONS } from './state.js';
+import type { StatsData } from '../monitors/index.js';
+
+/**
+ * How many process rows we can realistically fit given
+ * current terminal height.  Computed from the number of
+ * card columns and the reserved space for the header,
+ * cards, graphs, and footer.
+ */
+function processRowBudget(): number {
+  const columns = gridColumns(state.termWidth);
+  const visibleCards = Object.values(state.visiblePanels).filter(v => v !== false).length;
+  const cardRows = Math.ceil(visibleCards / columns);
+  const reserved = 2 + cardRows * 8 + 11 + (state.showGraphs ? 9 : 0) + 4;
+  return Math.max(3, Math.min(40, state.termHeight - reserved));
+}
+
+function renderCustomizerOverlay(): string {
+   const themesList = Object.keys(THEMES) as ThemeName[];
+   const lines = [
+     chalk.bgCyan.black.bold(' UI CUSTOMIZER (Use ↑/↓ or J/K to navigate, Enter/Space to toggle, Esc to exit) '),
+   ];
+
+   state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
+     const isSelected = idx === state.customizerIndex;
+     const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
+
+      if (opt === 'Theme') {
+        lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
+      } else if (opt === 'Graph Mode') {
+        lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
+      } else if (opt === 'Toggle Tree View') {
+
+       const status = state.treeView ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
+       lines.push(`${prefix}${opt}: ${status}`);
+     } else {
+       const key = opt.replace('Toggle ', '').toLowerCase();
+       const isVisible = state.visiblePanels[key as keyof typeof state.visiblePanels] !== false;
+       const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
+       lines.push(`${prefix}${opt}: ${status}`);
+     }
+   });
+
+   return lines.map(l => `  ${l}`).join('\n');
+ }
+
+function render() {
+  if (!state.lastData) return;
+  const lines: string[] = [];
+  lines.push(
+    formatTable(state.lastData, {
+      width: state.termWidth,
+      sortBy: state.sortMode,
+      filter: state.processFilter || undefined,
+      processLimit: processRowBudget(),
+      theme: state.currentTheme,
+      visible: state.visiblePanels,
+      treeView: state.treeView,
+      activePanel: state.activePanel,
+    })
+  );
+
+  if (state.showGraphs) {
+    lines.push('');
+    lines.push(formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode));
+  }
+
+  lines.push('');
+  lines.push(footerLine());
+
+  if (state.inputMode === 'customizer') {
+      lines.push(renderCustomizerOverlay());
+    } else if (state.inputMode === 'filter') {
+      lines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
+    } else if (state.inputMode === 'kill') {
+      lines.push(chalk.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
+     } else if (state.inputMode === 'signal') {
+       const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
+       const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk.yellow(s) : chalk.dim(s)).join('  ');
+       lines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
+       lines.push(chalk.dim(`  ${sigList}`));
+       lines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
+     } else if (state.statusMessage) {
+       lines.push(`  ${state.statusMessage}`);
+     }
+
+  process.stdout.write('\x1b[2J\x1b[H');
+  process.stdout.write(lines.join('\n'));
+}
+
+function footerLine(): string {
+   const keys: [string, string][] = [
+     ['q', 'quit'],
+     ['c', 'customize UI'],
+     ['p', state.paused ? 'resume' : 'pause'],
+      ['g', state.showGraphs ? 'hide graphs' : 'show graphs'],
+      ['b', `graph:${state.graphMode}`],
+      ['d', state.detailed ? 'basic' : 'detailed'],
+      ['←/→', 'tab'],
+      ['1-9', 'panels'],
+      ['s', `sort:${state.sortMode}`],
+      ['/', 'filter'],
+      ['k', 'kill'],
+      ['S', 'signal'],
+      ['t', state.treeView ? 'flat' : 'tree'],
+      ['e', 'export'],
+      ['l', state.logging ? 'stop log' : 'log'],
+      ['f', state.exportFormat],
+      ['+/-', `${state.interval}s`],
+    ];
+    const keyStr = keys.map(([k, label]) => `${chalk.hex('#50fa7b').bold(k)} ${chalk.dim(label)}`).join(chalk.dim('  |  '));
+
+
+   const badges: string[] = [];
+   if (state.paused) badges.push(chalk.yellow.bold('⏸ PAUSED'));
+   if (state.logging) badges.push(chalk.red.bold('● REC'));
+   if (state.activePanel !== 'grid') badges.push(chalk.cyan.bold(`◉ ${state.activePanel.toUpperCase()}`));
+   const badgeStr = badges.join('  ');
+
+   return badgeStr ? `${keyStr}    ${badgeStr}` : keyStr;
+  }
+
+function checkAlerts(data: StatsData) {
+  const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+  const hot = data.cpu.usage >= state.CPU_ALERT_PCT || (temp !== null && temp >= state.TEMP_ALERT_C);
+  if (hot && !state.alerted) {
+    state.alerted = true;
+    process.stdout.write('\x07');
+    const reason = data.cpu.usage >= state.CPU_ALERT_PCT ? `CPU at ${data.cpu.usage}%` : `Temp at ${temp}°C`;
+    setStatus(chalk.red(`⚠ Alert: ${reason}`), 5000);
+  } else if (!hot) {
+    state.alerted = false;
+  }
+}
+
+export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget };

package/src/live/state.ts

@@ -0,0 +1,103 @@
+/**
+ * Live dashboard session state.
+ *
+ * All mutable state for the interactive live mode lives
+ * in this module so that render, input, and export
+ * sub-modules can share it without circular dependencies.
+ */
+import fs from 'node:fs';
+import readline from 'node:readline';
+import { History } from '../history.js';
+import type { StatsData } from '../monitors/index.js';
+import type { ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
+import type { ThemeName, VisibleItems } from '../formatters/types.js';
+
+export const SIGNAL_OPTIONS = ['SIGTERM', 'SIGKILL', 'SIGINT', 'SIGHUP', 'SIGSTOP', 'SIGCONT'] as const;
+
+const state = {
+   intervalHandle: null as NodeJS.Timeout | null,
+   running: false,
+   paused: false,
+   detailed: false,
+    interval: 2,
+    showGraphs: true,
+    graphMode: 'spark' as GraphMode,
+    exportFormat: 'json' as ExportFormat,
+
+
+   exportDir: './pyre-exports',
+   currentTheme: 'default' as ThemeName,
+    visiblePanels: {
+      cpu: true,
+      mem: true,
+      gpu: true,
+      power: true,
+      battery: true,
+      thermal: true,
+      network: true,
+      packets: true,
+      tasks: true,
+      disk: true,
+      process: true,
+    } as VisibleItems,
+   logging: false,
+   logStream: null as fs.WriteStream | null,
+   statusMessage: '',
+   statusTimer: null as NodeJS.Timeout | null,
+   lastData: null as StatsData | null,
+   history: new History(40),
+   keypressHandler: null as ((str: string, key: readline.Key) => void) | null,
+   termWidth: process.stdout.columns || 80,
+   termHeight: process.stdout.rows || 24,
+   sortMode: 'cpu' as SortMode,
+   processFilter: '',
+   inputMode: null as InputMode,
+   inputBuffer: '',
+   treeView: false,
+   SIGNAL_OPTIONS,
+   customizerIndex: 0,
+    CUSTOMIZER_OPTIONS: [
+      'Theme',
+      'Graph Mode',
+      'Toggle CPU',
+      'Toggle Memory',
+      'Toggle GPU',
+      'Toggle Power',
+      'Toggle Battery',
+      'Toggle Thermal',
+      'Toggle Network',
+      'Toggle Packets',
+      'Toggle Tasks',
+      'Toggle Disk',
+      'Toggle Processes',
+      'Toggle Tree View',
+    ],
+   CPU_ALERT_PCT: 90,
+   TEMP_ALERT_C: 95,
+   alerted: false,
+   activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process',
+   mouseEnabled: true,
+    PANEL_TABS: [
+      { id: 'cpu', label: 'CPU', key: '1' },
+      { id: 'mem', label: 'Memory', key: '2' },
+      { id: 'gpu', label: 'GPU', key: '3' },
+      { id: 'power', label: 'Power', key: '4' },
+      { id: 'battery', label: 'Battery', key: '5' },
+      { id: 'thermal', label: 'Thermal', key: '6' },
+      { id: 'network', label: 'Network', key: '7' },
+      { id: 'packets', label: 'Packets', key: '8' },
+      { id: 'tasks', label: 'Tasks', key: '9' },
+      { id: 'disk', label: 'Disk', key: '0' },
+      { id: 'process', label: 'Process', key: 'P' },
+    ] as const,
+  };
+
+function setStatus(msg: string, ms = 3000) {
+  state.statusMessage = msg;
+  if (state.statusTimer) clearTimeout(state.statusTimer);
+  state.statusTimer = setTimeout(() => {
+    state.statusMessage = '';
+  }, ms);
+}
+
+export { state, setStatus };