pyre-cli 10.3.0 → 10.5.0

package/src/index.ts

@@ -102,10 +102,34 @@ program
     .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');
+    .option('--scan', 'Perform active network sweep on LAN neighbors for topology map')
+    .option('--idle <duration>', 'Idle threshold for optimize apps (e.g. 30m, 2h)')
+    .option('--keep <n>', 'Always keep the N most recently used apps open (optimize)')
+    .option('-y, --yes', 'Skip confirmation prompts (optimize)')
+    .option('--force', 'Terminate apps that do not quit gracefully (optimize apps)')
+    .option('--clean', 'Delete measured caches after confirmation (optimize caches)')
+    .option('--empty', 'Empty the Trash after confirmation (optimize trash)')
+    .option('--auto-quit <duration>', 'Let the optimize tracker automatically quit apps idle this long')
+    .option('-m, --menu', 'Launch interactive TUI command center & tools navigator')
+    .option('-i, --interactive', 'Alias for --menu')
+    .option('--budget-cpu <pct>', 'Maximum allowable peak CPU % for pyre run')
+    .option('--budget-mem <bytes>', 'Maximum allowable peak memory for pyre run (e.g. 500MB, 2GB)')
+    .option('--budget-time <sec>', 'Maximum allowable duration for pyre run in seconds')
+    .option('--nice <val>', 'Nice value for pyre inspect --nice (-20 to 19)')
+    .option('--format <format>', 'Output format for statusline (tmux, starship, json, pango, plain)');
 
 program.addHelpText('after', `
+  💡 Tip: Can't remember all commands? Run 'pyre menu' to browse and run all tools interactively!
+
  Commands:
+   menu, tui, launcher            Interactive TUI command center & tools navigator
+   playbook [run|list]            Execute sequenced multi-step macro recipes (audit, clean, triage)
+   flight [dump|status|record]    Forensic flight recorder black box in RAM
+   run [options] -- <cmd...>      Performance budgeting runner for CI/CD gates
+   bench-git <b1> <b2> <cmd>      Cross-branch git performance differ
+   statusline                     Headless terminal statusline string (tmux, starship, neovim)
+   inspect <pid>                  Process deep-dive inspector (lsof, sockets, nice)
+   containers                     Container and micro-VM telemetry (Docker, Podman, OrbStack)
    live                           Interactive live dashboard
    check                          One-line plain-English health summary
    pipe                           Continuous newline-delimited JSON stream for scripting
@@ -143,6 +167,8 @@ program.addHelpText('after', `
    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
+   optimize [apps|track|memory|caches|trash|startup|dns]
+                                  Mac optimizer: quit idle apps, free memory, clean caches
  `);
 
 program.parse(process.argv);
@@ -226,6 +252,106 @@ async function main() {
 
   const cmd = program.args[0];
 
+  if (cmd === 'menu' || cmd === 'tui' || cmd === 'launcher' || cmd === 'interactive' || opts.menu || opts.interactive) {
+    const { runMenu } = await import('./menu/index.js');
+    await runMenu({
+      theme: opts.theme || config.theme,
+    });
+    return;
+  }
+
+  if (!cmd && config.defaultAction === 'menu' && !isExportMode() && !opts.once && process.stdout.isTTY) {
+    const { runMenu } = await import('./menu/index.js');
+    await runMenu({
+      theme: opts.theme || config.theme,
+    });
+    return;
+  }
+
+  if (cmd === 'playbook') {
+    const sub = program.args[1];
+    const { runPlaybook, listPlaybooks } = await import('./playbookCmd.js');
+    if (sub === 'list' || !sub) {
+      listPlaybooks();
+    } else if (sub === 'run') {
+      const id = program.args[2] || 'audit';
+      await runPlaybook(id);
+    } else {
+      await runPlaybook(sub);
+    }
+    return;
+  }
+
+  if (cmd === 'flight') {
+    const sub = program.args[1] || 'dump';
+    const { runFlightCommand } = await import('./flightRecorder.js');
+    await runFlightCommand(sub, {
+      out: opts.out,
+      duration: opts.duration ? parseInt(opts.duration, 10) : undefined,
+    });
+    return;
+  }
+
+  if (cmd === 'run') {
+    const rawArgs = process.argv;
+    const dashDashIdx = rawArgs.indexOf('--');
+    const targetCommand = dashDashIdx !== -1 ? rawArgs.slice(dashDashIdx + 1) : program.args.slice(1);
+    const { runWithBudget, parseBytesString } = await import('./budgetCmd.js');
+    const res = await runWithBudget(targetCommand, {
+      maxCpuPct: opts.budgetCpu ? parseFloat(opts.budgetCpu) : undefined,
+      maxMemoryBytes: opts.budgetMem ? parseBytesString(opts.budgetMem) : undefined,
+      maxTimeSec: opts.budgetTime ? parseFloat(opts.budgetTime) : undefined,
+    }, {
+      markdown: !!opts.markdown || !!opts.md,
+      outFile: opts.out,
+    });
+    if (res.exitCode !== 0) {
+      process.exit(res.exitCode);
+    }
+    if (res.violations.length > 0) {
+      process.exit(124);
+    }
+    return;
+  }
+
+  if (cmd === 'bench-git') {
+    const branchA = program.args[1];
+    const branchB = program.args[2];
+    const commandStr = program.args.slice(3).join(' ');
+    if (!branchA || !branchB || !commandStr) {
+      console.log(chalk.red('  ✖ Usage: pyre bench-git <branchA> <branchB> "<command>"'));
+      process.exit(1);
+    }
+    const { runBenchGitCommand } = await import('./benchGitCmd.js');
+    await runBenchGitCommand(branchA, branchB, commandStr);
+    return;
+  }
+
+  if (cmd === 'statusline') {
+    const { runStatuslineCommand } = await import('./statuslineCmd.js');
+    await runStatuslineCommand(opts.format || 'plain');
+    return;
+  }
+
+  if (cmd === 'inspect') {
+    const targetPid = parseInt(program.args[1], 10);
+    const { runInspectCommand } = await import('./inspectCmd.js');
+    const niceVal = opts.nice !== undefined ? parseInt(opts.nice, 10) : undefined;
+    await runInspectCommand(targetPid, {
+      nice: niceVal,
+      json: !!opts.json,
+    });
+    return;
+  }
+
+  if (cmd === 'containers') {
+    const { runContainersCommand } = await import('./containersCmd.js');
+    await runContainersCommand({
+      json: !!opts.json,
+    });
+    return;
+  }
+
   if (cmd === 'check') {
     const { runCheckCommand } = await import('./checkCmd.js');
     await runCheckCommand({
@@ -309,6 +435,23 @@ async function main() {
     return;
   }
 
+  if (cmd === 'optimize') {
+    const { runOptimizeCommand } = await import('./optimizeCmd.js');
+    await runOptimizeCommand(program.args[1], program.args.slice(2), {
+      idle: opts.idle,
+      keep: opts.keep,
+      yes: !!opts.yes,
+      force: !!opts.force,
+      clean: !!opts.clean,
+      empty: !!opts.empty,
+      dryRun: !!opts.dryRun,
+      install: !!opts.install,
+      uninstall: !!opts.uninstall,
+      autoQuit: opts.autoQuit,
+    });
+    return;
+  }
+
   if (cmd === 'replay') {
     const file = program.args[1];
     if (!file) {
@@ -580,7 +723,12 @@ async function main() {
   }
 
   if (cmd === 'xbar') {
-    generateXbarPlugin();
+    const sub = program.args[1];
+    await generateXbarPlugin({
+      install: !!opts.install || sub === 'install',
+      yes: !!opts.yes,
+      dir: opts.dir,
+    });
     return;
   }
 
@@ -624,9 +772,13 @@ async function main() {
   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 && cmd !== 'live' && cmd !== 'p2p') {
+    console.error(chalk.red(`\n  ✖ Unknown command: '${cmd}'`));
+    console.log(chalk.yellow(`  💡 Tip: Can't remember a command? Run 'pyre menu' to browse and run all tools interactively!\n`));
+    process.exit(1);
+  }
 
-  if (cmd === 'live' || (!isExportMode() && !opts.once && cmd !== 'p2p')) {
+  if (cmd === 'live' || (!cmd && !isExportMode() && !opts.once)) {
     if (!process.stdout.isTTY && cmd !== 'live') {
       await runWebCommand();
       return;
@@ -640,6 +792,7 @@ async function main() {
       animation: config.splashAnimation as any,
     });
     const interval = parseFloat(opts.interval) || 2;
+    const tempUnit: 'c' | 'f' = (opts.tempUnit?.toLowerCase() === 'f' || config.tempUnit === 'f') ? 'f' : 'c';
     await startLive({
       interval,
       detailed: opts.detailed ?? config.detailed,
@@ -674,13 +827,14 @@ async function main() {
 
   const data = await collectAll({ detailed: opts.detailed, processLimit });
 
+  const tempUnit: 'c' | 'f' = (opts.tempUnit?.toLowerCase() === 'f' || config.tempUnit === 'f') ? 'f' : 'c';
   let output: string;
   if (opts.json) output = formatJson(data);
   else if (opts.html) output = formatHtml(data);
   else if (opts.md) output = formatMarkdown(data);
   else if (opts.csv) output = formatCsv(data);
   else if (opts.tsv) output = formatTsv(data);
-  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree ?? config.treeView, minimal: !!opts.minimal, visible: { packets: opts.packets ? true : undefined } });
+  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree ?? config.treeView, minimal: !!opts.minimal, visible: { packets: opts.packets ? true : undefined }, tempUnit });
 
   console.log(output);
 
@@ -932,6 +1086,25 @@ async function runInfoCommand(): Promise<void> {
     }
   }
 
+  if (process.platform === 'win32') {
+    lines.push('');
+    lines.push(chalk.cyan.bold('  ⏱ System Restore & Recovery:'));
+    try {
+      const { runPowerShell } = await import('./monitors/run.js');
+      const srRaw = await runPowerShell(
+        `(Get-CimInstance -Namespace root/default -ClassName SystemRestore -ErrorAction SilentlyContinue | Select-Object -Last 1 -ExpandProperty Description) -join ''`,
+        ''
+      );
+      if (srRaw.trim()) {
+        lines.push(`    • Latest Restore Point: ${chalk.green(srRaw.trim())}`);
+      } else {
+        lines.push('    • System Restore active (no custom checkpoints)');
+      }
+    } catch {
+      lines.push('    • System Restore available');
+    }
+  }
+
   console.log(lines.join('\n'));
 }
 
@@ -1729,10 +1902,10 @@ async function runBenchCommand(benchCmd: string): Promise<void> {
   let powerSamplesCount = 0;
 
   const child = process.platform === 'win32'
-    ? spawn('cmd.exe', ['/c', benchCmd], { stdio: 'inherit' })
+    ? spawn('cmd.exe', ['/c', benchCmd])
     : spawn('sh', ['-c', benchCmd]);
-  child.stdout.on('data', d => process.stdout.write(d));
-  child.stderr.on('data', d => process.stdout.write(d));
+  if (child.stdout) child.stdout.on('data', d => process.stdout.write(d));
+  if (child.stderr) child.stderr.on('data', d => process.stdout.write(d));
 
   const interval = parseFloat(opts.interval) || 2;
   const handle = setInterval(async () => {

package/src/inspectCmd.ts

@@ -0,0 +1,165 @@
+/**
+ * pyre inspect — Deep-Dive Process Inspector.
+ *
+ * Inspects low-level attributes for a running PID:
+ * open file handles (lsof), active sockets, thread count,
+ * nice priority, and memory regions.
+ */
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { formatBytes } from './budgetCmd.js';
+
+export interface ProcessDetails {
+  pid: number;
+  name: string;
+  user: string;
+  ppid: number;
+  threads: number;
+  nice: number;
+  cpuPct: number;
+  memRssBytes: number;
+  openFiles: string[];
+  sockets: string[];
+}
+
+export function inspectProcess(pid: number): ProcessDetails {
+  // Check if process exists
+  try {
+    process.kill(pid, 0);
+  } catch (err: any) {
+    if (err.code === 'ESRCH') {
+      throw new Error(`Process with PID ${pid} not found or permission denied.`);
+    }
+  }
+
+  // Query ps metadata
+  let name = 'unknown';
+  let user = 'unknown';
+  let ppid = 0;
+  let threads = 1;
+  let nice = 0;
+  let cpuPct = 0;
+  let memRssBytes = 0;
+
+  try {
+    const psOut = execSync(`ps -p ${pid} -o user,ppid,nice,%cpu,rss,comm 2>/dev/null`, { encoding: 'utf-8' });
+    const lines = psOut.trim().split('\n');
+    if (lines.length > 1) {
+      const parts = lines[1].trim().split(/\s+/);
+      user = parts[0] || 'unknown';
+      ppid = parseInt(parts[1], 10) || 0;
+      nice = parseInt(parts[2], 10) || 0;
+      cpuPct = parseFloat(parts[3]) || 0;
+      memRssBytes = (parseInt(parts[4], 10) || 0) * 1024;
+      name = parts.slice(5).join(' ') || 'unknown';
+    }
+  } catch {
+    // Fallback if ps is restricted or unavailable
+    if (pid === process.pid) {
+      try {
+        user = os.userInfo().username || 'current';
+      } catch {
+        user = process.env.USER || 'current';
+      }
+      ppid = process.ppid || 0;
+      name = process.title || 'node';
+      memRssBytes = process.memoryUsage().rss;
+      threads = 1;
+    }
+  }
+
+  // Query lsof for open files and network sockets
+  const openFiles: string[] = [];
+  const sockets: string[] = [];
+
+  try {
+    const lsofOut = execSync(`lsof -p ${pid} -F tn 2>/dev/null`, { encoding: 'utf-8' });
+    const lines = lsofOut.split('\n');
+    let curType = '';
+
+    for (const l of lines) {
+      if (l.startsWith('t')) {
+        curType = l.slice(1).trim();
+      } else if (l.startsWith('n')) {
+        const nameVal = l.slice(1).trim();
+        if (curType === 'IPv4' || curType === 'IPv6' || nameVal.includes(':') || nameVal.includes('->')) {
+          sockets.push(nameVal);
+        } else if (nameVal.startsWith('/') && !openFiles.includes(nameVal)) {
+          openFiles.push(nameVal);
+        }
+      }
+    }
+  } catch {
+    // lsof may not have permissions for system PIDs without sudo
+  }
+
+  return {
+    pid,
+    name,
+    user,
+    ppid,
+    threads,
+    nice,
+    cpuPct,
+    memRssBytes,
+    openFiles: openFiles.slice(0, 15),
+    sockets: sockets.slice(0, 15),
+  };
+}
+
+export async function runInspectCommand(pid: number, opts?: { nice?: number; json?: boolean }): Promise<void> {
+  if (isNaN(pid) || pid <= 0) {
+    console.error(chalk.red('  ✖ Invalid PID. Usage: pyre inspect <pid>'));
+    return;
+  }
+
+  // If renicing requested
+  if (opts?.nice !== undefined) {
+    try {
+      execSync(`renice ${opts.nice} -p ${pid}`, { stdio: 'inherit' });
+      console.log(chalk.green(`  ✔ Successfully set nice priority for PID ${pid} to ${opts.nice}\n`));
+    } catch (err: any) {
+      console.error(chalk.red(`  ✖ Failed to renice PID ${pid}: ${err.message}`));
+    }
+  }
+
+  try {
+    const details = inspectProcess(pid);
+
+    if (opts?.json) {
+      console.log(JSON.stringify(details, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n  🔥 pyre inspect — Process Deep Dive (PID ${details.pid})\n`));
+    console.log(`  Process:     ${chalk.bold.hex('#ff6a39')(details.name)}`);
+    console.log(`  User:        ${details.user}`);
+    console.log(`  PPID:        ${details.ppid}`);
+    console.log(`  CPU Usage:   ${details.cpuPct.toFixed(1)}%`);
+    console.log(`  Memory RSS:  ${formatBytes(details.memRssBytes)}`);
+    console.log(`  Nice Value:  ${details.nice} (Priority: ${details.nice < 0 ? 'High' : details.nice > 0 ? 'Low' : 'Normal'})`);
+    console.log(chalk.dim('  ─────────────────────────────────────────────────────────────'));
+
+    // Open sockets
+    console.log(chalk.bold.cyan('\n  Active Network Sockets:'));
+    if (details.sockets.length === 0) {
+      console.log(chalk.dim('    No open sockets detected (or permission denied).'));
+    } else {
+      details.sockets.forEach((s) => console.log(`    • ${s}`));
+    }
+
+    // Open file descriptors
+    console.log(chalk.bold.yellow('\n  Open File Descriptors:'));
+    if (details.openFiles.length === 0) {
+      console.log(chalk.dim('    No open file handles detected.'));
+    } else {
+      details.openFiles.forEach((f) => console.log(`    • ${chalk.dim(f)}`));
+    }
+
+    console.log(chalk.dim('\n  ─────────────────────────────────────────────────────────────'));
+    console.log(chalk.dim(`  Adjust priority: pyre inspect ${pid} --nice <value -20 to 19>\n`));
+  } catch (err: any) {
+    console.error(chalk.red(`\n  ✖ ${err.message}\n`));
+  }
+}

package/src/live/input.ts

@@ -7,6 +7,7 @@
  * Imported by `index.ts` as the public API of the live module.
  */
 import readline from 'node:readline';
+import { execSync } from 'node:child_process';
 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';
@@ -218,6 +219,9 @@ function isEscKey(key: readline.Key, str?: string): boolean {
           case 'Resume Dashboard':
             state.inputMode = null;
             break;
+          case 'Command Center (All Tools)':
+            openCommandCenter();
+            return;
           case 'Settings (Customizer)':
             state.inputMode = 'customizer';
             state.customizerIndex = 0;
@@ -437,20 +441,31 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
      return;
    }
 
-   const isProtected = pid === 1 || pid === process.pid || pid === process.ppid;
+   const isProtected = pid === 1 || pid === 0 || pid === 4 || pid === process.pid || pid === process.ppid;
    if (isProtected && confirmKillPid !== pid) {
      confirmKillPid = pid;
-     const name = pid === 1 ? 'launchd (system init)' : (pid === process.pid ? 'pyre itself' : 'parent process');
+     const name = (pid === 0 || pid === 4) ? 'Windows System Kernel' : (pid === 1 ? 'init/launchd' : (pid === process.pid ? 'pyre itself' : 'parent process'));
      setStatus(`⚠️ PROTECTED PID ${pid} (${name})! Re-enter PID ${pid} to confirm termination.`, 8000);
      return;
    }
 
    confirmKillPid = null;
+
+   if (process.platform === 'win32') {
+     try {
+       execSync(`taskkill /F /PID ${pid} /T`, { stdio: 'pipe' });
+       setStatus(`Terminated PID ${pid} (taskkill /F /T)`);
+       return;
+     } catch (err: any) {
+       // fallback to process.kill
+     }
+   }
+
    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}`);
+     setStatus(`Failed to terminate PID ${pid}: ${err.message}`);
    }
   }
 
@@ -576,6 +591,51 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
     }
   }
 
+  async function openCommandCenter() {
+    state.paused = true;
+    if (state.intervalHandle) {
+      clearInterval(state.intervalHandle);
+      state.intervalHandle = null;
+    }
+    if (state.uiIntervalHandle) {
+      clearInterval(state.uiIntervalHandle);
+      state.uiIntervalHandle = null;
+    }
+    if (state.keypressHandler) {
+      process.stdin.removeListener('keypress', state.keypressHandler);
+    }
+    process.stdout.removeListener('resize', onResize);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.stdout.write('\x1b[?1000l\x1b[?25h\x1b[?1049l\x1b[2J\x1b[H');
+
+    const { runMenu } = await import('../menu/index.js');
+    await runMenu({
+      theme: state.currentTheme,
+      onExit: () => {},
+    });
+
+    process.stdout.write('\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H');
+    if (state.mouseEnabled) {
+      process.stdout.write('\x1b[?1000h');
+    }
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    if (state.keypressHandler) {
+      process.stdin.on('keypress', state.keypressHandler);
+    }
+    process.stdout.on('resize', onResize);
+    state.paused = false;
+    state.inputMode = null;
+    restartTicker();
+    if (state.uiIntervalHandle) clearInterval(state.uiIntervalHandle);
+    state.uiIntervalHandle = setInterval(() => {
+      if (state.running && !state.paused) render();
+    }, 250);
+    render();
+  }
+
  /**
   * Start the interactive live dashboard.
   *
@@ -766,6 +826,10 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
         case 'right':
           cycleTab(1);
           break;
+        case 'o':
+        case 'O':
+          openCommandCenter();
+          return;
         case 'c':
           state.inputMode = 'customizer';
           state.customizerIndex = 0;
@@ -1047,6 +1111,9 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
 
     // Execute the command
     switch (cmd.id) {
+      case 'command-center':
+        openCommandCenter();
+        break;
       case 'cpu': case 'mem': case 'gpu': case 'power': case 'battery':
       case 'thermal': case 'network': case 'packets': case 'tasks': case 'disk':
       case 'process': case 'containers': case 'p2p': case 'anomalies': case 'blender':

package/src/live/render.ts

@@ -502,6 +502,7 @@ function render() {
 function footerLine(): string[] {
    const row1: [string, string][] = [
       ['q', 'quit'],
+      ['o', 'tools menu'],
       ['c', 'customize UI'],
       ['←/→', 'tab'],
       ['1-9', 'panels'],
@@ -509,7 +510,6 @@ function footerLine(): string[] {
       ['b', `graph:${state.graphMode}`],
       ['t', state.treeView ? 'flat' : 'tree'],
       ['d', state.detailed ? 'basic' : 'detailed'],
-      ['T', `temp:${state.tempUnit}`],
       ['p', state.paused ? 'resume' : 'pause'],
     ];
    const row2: [string, string][] = [

package/src/live/state.ts

@@ -19,9 +19,10 @@ import { type SplashColorScheme, type SplashAnimation } from '../splash.js';
 
 export { type SplashColorScheme, type SplashAnimation };
 
-export const MENU_OPTIONS = ['Resume Dashboard', 'Settings (Customizer)', 'Readme', 'Credits', 'Quit pyre'] as const;
+export const MENU_OPTIONS = ['Resume Dashboard', 'Command Center (All Tools)', 'Settings (Customizer)', 'Readme', 'Credits', 'Quit pyre'] as const;
 
 const PALETTE_COMMANDS = [
+  { id: 'command-center', label: 'Command Center (Browse all tools)', keys: 'o', category: 'Navigation' },
   { id: 'cpu', label: 'Switch to CPU panel', keys: '1', category: 'Navigation' },
   { id: 'mem', label: 'Switch to Memory panel', keys: '2', category: 'Navigation' },
   { id: 'gpu', label: 'Switch to GPU panel', keys: '3', category: 'Navigation' },