pyre-cli 9.5.1 → 10.0.0

package/src/formatters/types.ts

@@ -24,6 +24,7 @@ export interface ThemeColors {
    disk: (s: string) => string;
    graphs: (s: string) => string;
    process: (s: string) => string;
+   blender: (s: string) => string;
 }
 
 export type { StatsData };
@@ -40,6 +41,8 @@ export interface VisibleItems {
    tasks?: boolean;
    disk?: boolean;
    process?: boolean;
+   containers?: boolean;
+   blender?: boolean;
    tree?: boolean;
 }
 
@@ -67,7 +70,7 @@ export interface TableOptions {
     /** Show process tree view instead of flat list. */
     treeView?: boolean;
     /** Active panel for detail/focus view. 'grid' means show all panels. */
-    activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies';
+    activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies' | 'containers' | 'blender';
     /** Active anomaly alerts from the statistical detector. */
     anomalies?: AnomalyAlert[];
     /** Historical anomaly alerts for the anomalies tab. */
@@ -88,4 +91,6 @@ export interface TableOptions {
     inspectProcess?: any;
     /** Minimal mode: renders only CPU, GPU, Memory, and Temperature as large glanceable gauges. */
     minimal?: boolean;
+    /** Current selected AI diagnosis model ID. */
+    aiModel?: string;
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
- * pyre - Mac system monitoring CLI
- * Monitors temps, cpu, memory, disk, battery, and system stats.
+ * pyre - Cross-platform system monitoring CLI
+ * Monitors temps, cpu, memory, disk, battery, and system stats on macOS, Linux, and Windows.
  * Live mode is a full interactive dashboard: graphs, pause/resume,
  * on-demand snapshot export, and continuous CSV logging.
  * P2P mode enables live data streaming between two systems over TCP.
@@ -18,7 +18,7 @@ import { startLive, stopLive } from './live/index.js';
 import { showSplash } from './splash.js';
 import { P2PServer, P2PClient } from './p2p/index.js';
 import { runDoctor, printDoctorReport } from './doctor.js';
-import { generateZshCompletions, generateBashCompletions, generateFishCompletions } from './completions.js';
+import { generateZshCompletions, generateBashCompletions, generateFishCompletions, generatePowerShellCompletions } from './completions.js';
 import { runHistoryCommand } from './historyCmd.js';
 import { runDiffCommand } from './diffCmd.js';
 import { readConfig, CONFIG_FILE } from './state/config.js';
@@ -34,7 +34,7 @@ const program = new Command();
 program
     .name('pyre')
     .version(pkg.version)
-    .description('Mac system monitoring CLI: interactive live dashboard, stats, graphs, export, packet monitor, battery predictor')
+    .description('Cross-platform system monitoring CLI: interactive live dashboard, stats, graphs, export, packet monitor, battery predictor')
     .option('-j, --json', 'Output as JSON')
     .option('--html', 'Output as HTML')
     .option('--md', 'Output as Markdown')
@@ -79,35 +79,64 @@ program
     .option('--no-wizard', 'Skip first-run interactive setup wizard')
     .option('--install', 'Install pyre web as a background launchd agent')
     .option('--uninstall', 'Uninstall pyre web launchd agent')
-    .option('--port <port>', 'Port number for web server mode', '3000');
+    .option('--port <port>', 'Port number for web server mode', '3000')
+    .option('--prometheus-port <port>', 'Port number for Prometheus exporter (default: 9090)', '9090')
+    .option('--speed <n>', 'Playback speed multiplier for pyre replay (default: 1)', '1')
+    .option('--llm-backend <backend>', 'AI backend: builtin (local zero-setup), ollama, or openai (default: builtin)', 'builtin')
+    .option('--llm-model <model>', 'AI model name for pyre explain (default: expert-rules-v1 / llama3.2 / gpt-4o-mini)')
+    .option('--api-key <key>', 'API key for OpenAI-compatible LLM backend (or set OPENAI_API_KEY env)')
+    .option('--alert-slack <url>', 'Slack webhook URL for alert notifications')
+    .option('--alert-discord <url>', 'Discord webhook URL for alert notifications')
+    .option('--alert-pushover-token <token>', 'Pushover application token for alert notifications')
+    .option('--alert-pushover-user <user>', 'Pushover user key for alert notifications')
+    .option('--alert-ntfy <url>', 'ntfy.sh topic URL for alert notifications (e.g. https://ntfy.sh/my-topic)')
+    .option('--watchdog-config <file>', 'Path to custom watchdog JSON configuration rules')
+    .option('--dry-run', 'Simulate actions in watchdog mode without executing kills')
+    .option('--top <n>', 'Number of items to display in netusage command (default: 15)')
+    .option('--raw', 'Print unparsed output for profiler')
+    .option('--sync-dir <dir>', 'Custom directory path for cloud profile/config sync')
+    .option('--scan', 'Perform active network sweep on LAN neighbors for topology map');
 
 program.addHelpText('after', `
-Commands:
-  live                           Interactive live dashboard
-  check                          One-line plain-English health summary
-  pipe                           Continuous newline-delimited JSON stream for scripting
-  stress                         Synthetic CPU/GPU load generator
-  ui                             Launch the native macOS UI dashboard
-  web                            Serve an auto-refreshing live web portal
-  ssh <host>                     Stream live stats from a remote Mac over SSH
-  fleet <host1> [host2]...       Multi-host live dashboard monitoring multiple Macs
-  bench <cmd>                    Log CPU, memory, network, power draw, and estimate kWh cost
-  benchmark                      Run a 1-minute CPU benchmark calculating digits of PI
-  anomalies                      Compute z-score anomalies and print plain-language digest
-  doctor                         Run system diagnostics
-  extensions                     System Extensions inspector
-  brew                           Homebrew health panel
-  update                         Check for pyre-cli updates
-  profile <save|load|list>       Atomic configuration profile management
-  config <show|reset>            View or reset persistent configuration file
-  history                        Graph historical resource trends from CSV logs
-  diff <file1> <file2>           Compare two saved snapshot files side-by-side
-  info                           Concise hardware summary
-  completions <shell>            Generate shell auto-completion scripts
-  xbar                           Generate an xbar / SwiftBar menu bar plugin script
-  p2p <server|connect>           Start a P2P server or connect to one
-  server                         Print commands for starting P2P server/client
-`);
+ Commands:
+   live                           Interactive live dashboard
+   check                          One-line plain-English health summary
+   pipe                           Continuous newline-delimited JSON stream for scripting
+   stress                         Synthetic CPU/GPU load generator
+   ui                             Launch the live UI dashboard window
+   web                            Serve an auto-refreshing live web portal
+   ssh <host>                     Stream live stats from a remote host over SSH
+   fleet <host1> [host2]...       Multi-host live dashboard monitoring multiple hosts
+   bench <cmd>                    Log CPU, memory, network, power draw, and estimate kWh cost
+   benchmark                      Run a 1-minute CPU benchmark calculating digits of PI
+   anomalies                      Compute z-score anomalies and print plain-language digest
+   doctor                         Run system diagnostics
+   extensions                     System Extensions / Driver inspector
+   brew                           Package manager health panel (brew/apt/pacman/winget)
+   update                         Check for pyre-cli updates
+   profile <save|load|list>       Atomic configuration profile management
+   config <show|reset>            View or reset persistent configuration file
+   history                        Graph historical resource trends from CSV logs
+   diff <file1> <file2>           Compare two saved snapshot files side-by-side
+   info                           Concise hardware summary
+   completions <shell>            Generate shell auto-completion scripts (zsh, bash, fish, powershell)
+   xbar                           Generate an xbar / SwiftBar menu bar plugin script
+   p2p <server|connect>           Start a P2P server or connect to one
+   server                         Print commands for starting P2P server/client
+   blender                        Track active Blender render jobs and their progress
+   prometheus                     Start a Prometheus metrics exporter on localhost
+   smart                          S.M.A.R.T. disk health report (requires smartmontools)
+   replay <file>                  Play back a pyre CSV log file in the TUI
+   explain                        AI-powered plain-English anomaly explanation (Ollama/OpenAI)
+   alert test                     Send a test notification to all configured alert channels
+   netusage                       Real-time per-application network usage breakdown
+   serve                          Lightweight structured JSON REST API server
+   profile-proc <pid>             CPU call-tree profiler and hot function sampler
+   watchdog                       Persistent autonomous monitoring daemon and rules engine
+   build                          Active compiler and build system tracker
+   topo                           Network topology mapper and pyre peer auto-discovery
+   sync <push|pull|status>        Synchronize config profiles across Macs via iCloud/Drive
+ `);
 
 program.parse(process.argv);
 
@@ -233,6 +262,184 @@ async function main() {
     return;
   }
 
+  if (cmd === 'blender') {
+    const { collectBlenderRenders } = await import('./monitors/blender.js');
+    const renders = await collectBlenderRenders();
+    if (!renders.length) {
+      console.log(chalk.dim('No active Blender renders detected.'));
+      return;
+    }
+    const lines: string[] = [];
+    lines.push(chalk.bold('  Blender Render Tracker'));
+    lines.push('');
+    for (const r of renders) {
+      const statusColor = r.status === 'rendering' ? chalk.green : r.status === 'finalizing' ? chalk.yellow : r.status === 'loading' ? chalk.cyan : chalk.dim;
+      lines.push(`  PID:         ${r.pid}`);
+      lines.push(`  Blend File:  ${r.blendFile}`);
+      lines.push(`  Engine:      ${r.renderEngine}`);
+      lines.push(`  Frames:      ${r.currentFrame} / ${r.totalFrames}  (${r.completionPercent}%)`);
+      lines.push(`  Elapsed:     ${r.elapsedSec}s`);
+      lines.push(`  Status:      ${statusColor(r.status)}`);
+      lines.push(`  Output:      ${r.outputPath}`);
+      if (r.sampleCount !== undefined) lines.push(`  Samples:     ${r.sampleCount}`);
+      lines.push('');
+    }
+    console.log(lines.join('\n'));
+    return;
+  }
+
+  if (cmd === 'prometheus') {
+    const { runPrometheusServer } = await import('./prometheusCmd.js');
+    const prometheusPort = parseInt(opts.prometheusPort, 10) || 9090;
+    const intervalSec = parseFloat(opts.interval) || 15;
+    await runPrometheusServer({ port: prometheusPort, interval: intervalSec, detailed: opts.detailed });
+    return;
+  }
+
+  if (cmd === 'smart') {
+    const { runSmartCommand } = await import('./smartCmd.js');
+    await runSmartCommand();
+    return;
+  }
+
+  if (cmd === 'replay') {
+    const file = program.args[1];
+    if (!file) {
+      console.error(chalk.red('  ✖ Usage: pyre replay <logfile.csv>'));
+      process.exit(1);
+    }
+    const { runReplayCommand } = await import('./replayCmd.js');
+    await runReplayCommand({
+      file,
+      speed: parseFloat(opts.speed) || 1,
+      plain: opts.plain || opts.a11y,
+    });
+    return;
+  }
+
+  if (cmd === 'explain') {
+    const { runExplainCommand } = await import('./explainCmd.js');
+    const backend = opts.llmBackend === 'openai' ? 'openai' : opts.llmBackend === 'ollama' ? 'ollama' : 'builtin';
+    await runExplainCommand({
+      since: opts.since || '7d',
+      backend,
+      model: opts.llmModel,
+      apiKey: opts.apiKey,
+      dir: opts.exportDir,
+    });
+    return;
+  }
+
+  if (cmd === 'alert') {
+    const sub = program.args[1];
+    if (sub === 'test') {
+      const { sendTestAlert } = await import('./alertChannels.js');
+      const { writeConfig } = await import('./state/config.js');
+      // Persist any channel flags passed on CLI before sending test
+      if (opts.alertSlack || opts.alertDiscord || opts.alertPushoverToken || opts.alertPushoverUser || opts.alertNtfy) {
+        writeConfig({
+          slackAlertUrl: opts.alertSlack || config.slackAlertUrl,
+          discordAlertUrl: opts.alertDiscord || config.discordAlertUrl,
+          pushoverToken: opts.alertPushoverToken || config.pushoverToken,
+          pushoverUser: opts.alertPushoverUser || config.pushoverUser,
+          ntfyUrl: opts.alertNtfy || config.ntfyUrl,
+        });
+      }
+      const testConfig = {
+        slackUrl: opts.alertSlack || config.slackAlertUrl || undefined,
+        discordUrl: opts.alertDiscord || config.discordAlertUrl || undefined,
+        pushoverToken: opts.alertPushoverToken || config.pushoverToken || undefined,
+        pushoverUser: opts.alertPushoverUser || config.pushoverUser || undefined,
+        ntfyUrl: opts.alertNtfy || config.ntfyUrl || undefined,
+      };
+      const hasAny = Object.values(testConfig).some(v => !!v);
+      if (!hasAny) {
+        console.log(chalk.yellow('\n  ⚠ No alert channels configured.'));
+        console.log(chalk.dim('  Use --alert-slack <url>, --alert-discord <url>, --alert-ntfy <url>, etc.\n'));
+        return;
+      }
+      console.log(chalk.bold('\n  🔥 pyre alert test — firing test notification...\n'));
+      await sendTestAlert(testConfig);
+      console.log(chalk.green('  ✔ Test alert sent to all configured channels.\n'));
+    } else {
+      console.log(chalk.yellow('  Usage: pyre alert test'));
+    }
+    return;
+  }
+
+  if (cmd === 'netusage') {
+    const { runNetUsageCommand } = await import('./netUsageCmd.js');
+    await runNetUsageCommand({
+      top: opts.top ? parseInt(opts.top, 10) : 15,
+      sort: (opts.sort === 'rx' || opts.sort === 'tx') ? opts.sort : 'total',
+      json: !!opts.json,
+    });
+    return;
+  }
+
+  if (cmd === 'serve') {
+    const { runServeCommand } = await import('./serveCmd.js');
+    const port = parseInt(opts.port, 10) || 8080;
+    await runServeCommand({
+      port,
+      apiKey: opts.apiKey,
+      detailed: opts.detailed,
+    });
+    return;
+  }
+
+  if (cmd === 'profile-proc') {
+    const targetPid = parseInt(program.args[1], 10);
+    if (isNaN(targetPid)) {
+      console.error(chalk.red('  ✖ Usage: pyre profile-proc <pid> [--duration <sec>]'));
+      process.exit(1);
+    }
+    const { runProfileProcCommand } = await import('./profileProcCmd.js');
+    const durationSec = parseFloat(opts.duration) || 5;
+    await runProfileProcCommand({
+      pid: targetPid,
+      durationSec,
+      raw: !!opts.raw,
+    });
+    return;
+  }
+
+  if (cmd === 'watchdog') {
+    const { runWatchdogCommand } = await import('./watchdogCmd.js');
+    await runWatchdogCommand({
+      configFile: opts.watchdogConfig,
+      dryRun: !!opts.dryRun,
+      interval: parseFloat(opts.interval) || 2,
+    });
+    return;
+  }
+
+  if (cmd === 'build') {
+    const { runBuildCommand } = await import('./buildCmd.js');
+    await runBuildCommand({
+      json: !!opts.json,
+    });
+    return;
+  }
+
+  if (cmd === 'topo') {
+    const { runTopoCommand } = await import('./topoCmd.js');
+    await runTopoCommand({
+      scan: !!opts.scan,
+      json: !!opts.json,
+    });
+    return;
+  }
+
+  if (cmd === 'sync') {
+    const subcommand = program.args[1] || 'status';
+    const { runSyncCommand } = await import('./syncCmd.js');
+    await runSyncCommand(subcommand, {
+      syncDir: opts.syncDir,
+    });
+    return;
+  }
+
   if (cmd === 'brew') {
     const { printBrewHealthReport } = await import('./brewHealth.js');
     await printBrewHealthReport();
@@ -399,6 +606,12 @@ async function main() {
   if (opts.webhookUrl) config.webhookUrl = opts.webhookUrl;
   if (opts.alertCmd) config.alertCmd = opts.alertCmd;
   if (opts.exportDir) config.exportDir = opts.exportDir;
+  // Persist new alert channel options to config if provided
+  if (opts.alertSlack) config.slackAlertUrl = opts.alertSlack;
+  if (opts.alertDiscord) config.discordAlertUrl = opts.alertDiscord;
+  if (opts.alertPushoverToken) config.pushoverToken = opts.alertPushoverToken;
+  if (opts.alertPushoverUser) config.pushoverUser = opts.alertPushoverUser;
+  if (opts.alertNtfy) config.ntfyUrl = opts.alertNtfy;
   const tempUnit = opts.tempUnit === 'f' ? 'f' : 'c';
 
   if (cmd === 'live' || (!isExportMode() && !opts.once && cmd !== 'p2p')) {
@@ -669,7 +882,7 @@ async function runInfoCommand(): Promise<void> {
   const tmStatus = await getTimeMachineStatus();
 
   const lines: string[] = [];
-  lines.push(chalk.bold('  pyre info — Mac System Information'));
+  lines.push(chalk.bold(`  pyre info — System Information (${data.header.os})`));
   lines.push('');
   lines.push(`  Hostname:  ${data.header.hostname}`);
   lines.push(`  OS:        ${data.header.os}`);
@@ -696,13 +909,15 @@ async function runInfoCommand(): Promise<void> {
     }
   }
 
-  lines.push('');
-  lines.push(chalk.cyan.bold('  ⏱ Time Machine Backup:'));
-  if (!tmStatus.configured) {
-    lines.push('    • Not configured');
-  } else {
-    lines.push(`    • Status: ${tmStatus.running ? chalk.yellow(`Backup in progress (${tmStatus.percent || 0}%)`) : chalk.green('Idle')}`);
-    lines.push(`    • Latest Backup: ${tmStatus.latestBackup}`);
+  if (process.platform === 'darwin') {
+    lines.push('');
+    lines.push(chalk.cyan.bold('  ⏱ Time Machine Backup:'));
+    if (!tmStatus.configured) {
+      lines.push('    • Not configured');
+    } else {
+      lines.push(`    • Status: ${tmStatus.running ? chalk.yellow(`Backup in progress (${tmStatus.percent || 0}%)`) : chalk.green('Idle')}`);
+      lines.push(`    • Latest Backup: ${tmStatus.latestBackup}`);
+    }
   }
 
   console.log(lines.join('\n'));
@@ -850,12 +1065,29 @@ async function runWebCommand(): Promise<number> {
   });
 }
 
+async function openBrowserUrl(url: string): Promise<void> {
+  const { spawn } = await import('node:child_process');
+  const platform = process.platform;
+  if (platform === 'win32') {
+    spawn('cmd.exe', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });
+  } else if (platform === 'darwin') {
+    spawn('open', [url], { detached: true, stdio: 'ignore' });
+  } else {
+    spawn('xdg-open', [url], { detached: true, stdio: 'ignore' });
+  }
+}
+
 async function runUiCommand(): Promise<void> {
   // Use a random ephemeral port to avoid collisions
   opts.port = '0';
   const port = await runWebCommand();
-  
-  const swiftScript = `
+  const url = `http://localhost:${port}`;
+
+  if (process.platform === 'darwin') {
+    const { run } = await import('./monitors/run.js');
+    const hasSwift = (await run('which swift 2>/dev/null', '')).trim().length > 0;
+    if (hasSwift) {
+      const swiftScript = `
 import Cocoa
 import WebKit
 
@@ -958,23 +1190,31 @@ app.delegate = delegate
 app.run()
 `;
 
+      const scriptPath = path.join(os.tmpdir(), 'pyre-ui.swift');
+      fs.writeFileSync(scriptPath, swiftScript);
 
-  const scriptPath = path.join(os.tmpdir(), 'pyre-ui.swift');
-  fs.writeFileSync(scriptPath, swiftScript);
+      const { spawn } = await import('node:child_process');
+      console.log(chalk.cyan(`\n  Launching native UI window...`));
+      const ui = spawn('swift', [scriptPath], { stdio: 'inherit' });
+      
+      ui.on('close', () => {
+        console.log(chalk.dim('UI window closed, shutting down server...'));
+        process.exit(0);
+      });
 
-  const { spawn } = await import('node:child_process');
-  console.log(chalk.cyan(`\n  Launching native UI window...`));
-  const ui = spawn('swift', [scriptPath], { stdio: 'inherit' });
-  
-  ui.on('close', () => {
-    console.log(chalk.dim('UI window closed, shutting down server...'));
-    process.exit(0);
-  });
+      process.once('SIGINT', () => {
+        ui.kill();
+        process.exit(0);
+      });
+      return;
+    }
+  }
 
-  process.once('SIGINT', () => {
-    ui.kill();
-    process.exit(0);
-  });
+  // Cross-platform browser / app-mode launch for Linux, Windows, or macOS without Swift
+  console.log(chalk.cyan(`\n  Opening live UI dashboard at ${url}...`));
+  await openBrowserUrl(url);
+  console.log(chalk.dim('  Press Ctrl+C to stop server.\n'));
+  await new Promise(() => {});
 }
 
 async function runBenchCommand(benchCmd: string): Promise<void> {
@@ -994,7 +1234,9 @@ async function runBenchCommand(benchCmd: string): Promise<void> {
   let accumulatedWattSeconds = 0;
   let powerSamplesCount = 0;
 
-  const child = spawn('sh', ['-c', benchCmd]);
+  const child = process.platform === 'win32'
+    ? spawn('cmd.exe', ['/c', benchCmd], { stdio: 'inherit' })
+    : spawn('sh', ['-c', benchCmd]);
   child.stdout.on('data', d => process.stdout.write(d));
   child.stderr.on('data', d => process.stdout.write(d));
 

package/src/live/input.ts

@@ -16,6 +16,8 @@ import { render, footerLine, checkAlerts, invalidateTableCache, invalidateFrame
 import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode, ActivePanel } from './types.js';
 import { startP2PServer } from '../p2p/index.js';
 import { writeConfig } from '../state/config.js';
+import { AVAILABLE_AI_MODELS } from '../ai/models.js';
+import { loadPlugins, executePlugins } from '../plugins/index.js';
 
   function persistConfig() {
     writeConfig({
@@ -38,6 +40,9 @@ import { writeConfig } from '../state/config.js';
        splashAnimation: state.splashAnimation,
        visiblePanels: { ...state.visiblePanels },
        notificationsEnabled: state.notificationsEnabled,
+       dockerModeConfirmed: state.dockerModeConfirmed,
+       aiModel: state.aiModel,
+       aiBackend: state.aiBackend,
     });
   }
 
@@ -95,6 +100,25 @@ function handleInputModeKey(str: string, key: readline.Key) {
            } else if (selected === 'Temperature Unit') {
              state.tempUnit = state.tempUnit === 'c' ? 'f' : 'c';
              setStatus(`Temperature unit: ${state.tempUnit.toUpperCase()}`);
+           } else if (selected === 'AI Model') {
+             const curIdx = AVAILABLE_AI_MODELS.findIndex(m => m.id === state.aiModel);
+             const nextIdx = (curIdx + 1) % AVAILABLE_AI_MODELS.length;
+             state.aiModel = AVAILABLE_AI_MODELS[nextIdx].id;
+             state.aiBackend = AVAILABLE_AI_MODELS[nextIdx].backend;
+             setStatus(`AI Model: ${AVAILABLE_AI_MODELS[nextIdx].name}`);
+           } else if (selected === 'Grid Panel Order') {
+             // Rotate panelLayout
+             const layouts = [
+               ['mem', 'disk', 'net'],
+               ['disk', 'mem', 'net'],
+               ['net', 'mem', 'disk'],
+               ['mem', 'net', 'disk'],
+             ];
+             const currentStr = state.panelLayout.join(',');
+             const currentIdx = layouts.findIndex(l => l.join(',') === currentStr);
+             const nextIdx = (currentIdx + 1) % layouts.length;
+             state.panelLayout = layouts[nextIdx];
+             setStatus(`Panel layout: ${state.panelLayout.join(' → ')}`);
            } else {
             const toggleKey = getToggleKey(selected);
             if (toggleKey) {
@@ -179,6 +203,82 @@ function handleInputModeKey(str: string, key: readline.Key) {
       return;
     }
 
+    if (state.inputMode === 'docker-alert') {
+      if (isEscKey(key, str)) {
+        state.inputMode = null;
+        state.dockerModeConfirmed = true;
+        render();
+        return;
+      }
+      if (isUpKey(key, str)) {
+        state.dockerSelectionIndex = Math.max(0, state.dockerSelectionIndex - 1);
+        render();
+        return;
+      }
+      if (isDownKey(key, str)) {
+        state.dockerSelectionIndex = Math.min(1, state.dockerSelectionIndex + 1);
+        render();
+        return;
+      }
+      if (isEnterKey(key, str) || str === ' ') {
+        state.dockerModeConfirmed = true;
+        state.inputMode = null;
+        
+        if (state.dockerSelectionIndex === 0) {
+          // Docker Mode
+          state.visiblePanels.battery = false;
+          state.visiblePanels.thermal = false;
+          state.visiblePanels.power = false;
+          state.visiblePanels.gpu = false;
+          state.detailed = false;
+        } else {
+          // Regular TUI
+          state.visiblePanels.battery = true;
+          state.visiblePanels.thermal = true;
+          state.visiblePanels.power = true;
+          state.visiblePanels.gpu = true;
+        }
+        
+        invalidateTableCache();
+        invalidateFrame();
+        persistConfig();
+        render();
+        return;
+      }
+      return;
+    }
+
+    if (state.inputMode === 'ai-model') {
+      if (isEscKey(key, str)) {
+        state.inputMode = null;
+        render();
+        return;
+      }
+      if (isUpKey(key, str) || str === 'k') {
+        state.modelSelectionIndex = (state.modelSelectionIndex - 1 + AVAILABLE_AI_MODELS.length) % AVAILABLE_AI_MODELS.length;
+        render();
+        return;
+      }
+      if (isDownKey(key, str) || str === 'j') {
+        state.modelSelectionIndex = (state.modelSelectionIndex + 1) % AVAILABLE_AI_MODELS.length;
+        render();
+        return;
+      }
+      if (isEnterKey(key, str) || str === ' ') {
+        const chosen = AVAILABLE_AI_MODELS[state.modelSelectionIndex];
+        state.aiModel = chosen.id;
+        state.aiBackend = chosen.backend;
+        state.inputMode = null;
+        setStatus(`Active AI Model: ${chosen.name}`, 4000);
+        invalidateTableCache();
+        invalidateFrame();
+        persistConfig();
+        render();
+        return;
+      }
+      return;
+    }
+
     if (state.inputMode === 'signal') {
       if (isUpKey(key, str)) {
        const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
@@ -442,6 +542,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
      state.history.reset();
      state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
 
+    await loadPlugins().catch(() => {});
     const warmupPromise = doWarmup();
 
     if (splashPromise) {
@@ -540,6 +641,18 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           render();
           return;
         }
+         case 'C': {
+           state.activePanel = state.activePanel === 'containers' ? 'grid' : 'containers';
+           setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Containers panel');
+           render();
+           return;
+         }
+         case 'B': {
+           state.activePanel = state.activePanel === 'blender' ? 'grid' : 'blender';
+           setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Blender panel');
+           render();
+           return;
+         }
       }
 
       switch (key.name) {
@@ -568,6 +681,11 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           state.customizerIndex = 0;
           render();
           break;
+        case 'm':
+          state.inputMode = 'ai-model';
+          state.modelSelectionIndex = Math.max(0, AVAILABLE_AI_MODELS.findIndex(m => m.id === state.aiModel));
+          render();
+          break;
         case 'p':
           state.paused = !state.paused;
           setStatus(state.paused ? 'Paused' : 'Resumed');
@@ -716,16 +834,16 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
     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', 'r': 'p2p', 'A': 'anomalies' };
+  function tabKeyToId(str: string): ActivePanel | null {
+    const map: Record<string, ActivePanel> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process', 'C': 'containers', 'r': 'p2p', 'A': 'anomalies', 'B': 'blender' };
     return map[str] ?? null;
   }
 
   function cycleTab(direction: number) {
-    const tabs = state.PANEL_TABS.map(t => t.id);
+    const tabs = state.PANEL_TABS.map(t => t.id) as string[];
     const current = state.activePanel === 'grid' ? -1 : tabs.indexOf(state.activePanel);
     const next = (current + direction + tabs.length) % tabs.length;
-    state.activePanel = tabs[next];
+    state.activePanel = tabs[next] as typeof state.activePanel;
     setStatus(`Panel: ${state.activePanel.toUpperCase()}`);
     render();
   }