pyre-cli 10.1.0 → 10.3.0

package/dist/syncCmd-42IRF633.js

@@ -0,0 +1,246 @@
+import {
+  getConfigFile,
+  getProfilesDir,
+  readConfig,
+  writeConfig
+} from "./chunk-QM5L43EK.js";
+
+// src/syncCmd.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+import chalk from "chalk";
+function getDefaultSyncDir() {
+  if (process.env.PYRE_SYNC_DIR) return process.env.PYRE_SYNC_DIR;
+  const icloudPath = path.join(os.homedir(), "Library", "Mobile Documents", "com~apple~CloudDocs", "PyreSync");
+  if (fs.existsSync(path.dirname(icloudPath))) {
+    return icloudPath;
+  }
+  return path.join(os.homedir(), ".pyre-sync");
+}
+function computeDirChecksum(dirPath) {
+  const hash = crypto.createHash("sha256");
+  if (!fs.existsSync(dirPath)) return "";
+  const files = fs.readdirSync(dirPath).sort();
+  for (const file of files) {
+    const full = path.join(dirPath, file);
+    if (fs.statSync(full).isFile()) {
+      hash.update(file);
+      hash.update(fs.readFileSync(full));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function loadLocalProfiles() {
+  const profilesDir = getProfilesDir();
+  const profiles = {};
+  if (!fs.existsSync(profilesDir)) return profiles;
+  for (const f of fs.readdirSync(profilesDir).filter((f2) => f2.endsWith(".json"))) {
+    try {
+      const name = f.replace(/\.json$/, "");
+      profiles[name] = JSON.parse(fs.readFileSync(path.join(profilesDir, f), "utf-8"));
+    } catch {
+    }
+  }
+  return profiles;
+}
+function saveLocalProfiles(profiles) {
+  const profilesDir = getProfilesDir();
+  if (!fs.existsSync(profilesDir)) fs.mkdirSync(profilesDir, { recursive: true });
+  for (const [name, cfg] of Object.entries(profiles)) {
+    fs.writeFileSync(path.join(profilesDir, `${name}.json`), JSON.stringify(cfg, null, 2) + "\n");
+  }
+}
+async function runFirebaseSubcommand(action) {
+  const config = readConfig();
+  if (action === "enable") {
+    writeConfig({ firebaseSyncEnabled: true });
+    console.log(chalk.green("  \u2714 Firebase sync enabled."));
+    console.log(chalk.dim('  Run "pyre sync push" to upload your config and profiles to Firestore.\n'));
+    return;
+  }
+  if (action === "disable") {
+    writeConfig({ firebaseSyncEnabled: false });
+    console.log(chalk.yellow("  \u2714 Firebase sync disabled. Falling back to local folder sync.\n"));
+    return;
+  }
+  if (action === "status" || !action) {
+    console.log(chalk.bold(`  Firebase Sync: ${config.firebaseSyncEnabled ? chalk.green("ENABLED") : chalk.dim("DISABLED")}`));
+    if (!config.firebaseSyncEnabled) {
+      console.log(chalk.dim('  Run "pyre sync firebase enable" to activate.\n'));
+      return;
+    }
+    const { firebaseStatus } = await import("./firebaseSync-ON3RZ6KX.js");
+    const hosts = await firebaseStatus();
+    if (hosts.length === 0) {
+      console.log(chalk.dim('  No remote hosts found in Firestore. Run "pyre sync push" to upload.\n'));
+      return;
+    }
+    console.log();
+    for (const h of hosts) {
+      console.log(`  ${chalk.bold(h.sourceHost)} (${chalk.cyan(h.hostId)})`);
+      console.log(`    Last Updated:  ${chalk.green(h.lastUpdated)}`);
+      console.log(`    Profiles:      ${chalk.bold(String(h.profilesCount))}`);
+      console.log(`    Checksum:      ${chalk.dim(h.checksum)}
+`);
+    }
+    return;
+  }
+  console.log(chalk.yellow(`  Unknown firebase action: "${action}". Available: enable, disable, status
+`));
+}
+async function runSyncCommand(subcommand = "status", opts = {}) {
+  const config = readConfig();
+  console.log(chalk.bold("\n  \u{1F525} pyre sync \u2014 Configuration & Profile Cloud Sync\n"));
+  if (subcommand === "firebase") {
+    const action = process.argv[process.argv.indexOf("firebase") + 1] || "status";
+    await runFirebaseSubcommand(action);
+    return;
+  }
+  if (config.firebaseSyncEnabled) {
+    console.log(`  Backend: ${chalk.cyan("Firebase Firestore")} (${chalk.dim("dearborn-internal-tool")})`);
+    const hostId = config.firebaseHostId || void 0;
+    if (subcommand === "status") {
+      const { firebaseStatus } = await import("./firebaseSync-ON3RZ6KX.js");
+      const hosts = await firebaseStatus();
+      if (hosts.length === 0) {
+        console.log(chalk.dim('  No remote hosts found. Run "pyre sync push" to upload your config.\n'));
+        return;
+      }
+      console.log();
+      for (const h of hosts) {
+        console.log(`  ${chalk.bold(h.sourceHost)} (${chalk.cyan(h.hostId)})`);
+        console.log(`    Last Updated:  ${chalk.green(h.lastUpdated)}`);
+        console.log(`    Profiles:      ${chalk.bold(String(h.profilesCount))}`);
+        console.log(`    Checksum:      ${chalk.dim(h.checksum)}
+`);
+      }
+      return;
+    }
+    if (subcommand === "push") {
+      const { firebasePush } = await import("./firebaseSync-ON3RZ6KX.js");
+      const profiles = loadLocalProfiles();
+      const result = await firebasePush(config, profiles, hostId);
+      const profileCount = Object.keys(profiles).length;
+      console.log(chalk.green(`  \u2714 Successfully pushed config and ${profileCount} profile(s) to Firestore.`));
+      console.log(`  Host ID:   ${chalk.cyan(result.hostId)}`);
+      console.log(`  Checksum:  ${chalk.dim(result.checksum)}  |  Timestamp: ${chalk.dim(result.lastUpdated)}
+`);
+      return;
+    }
+    if (subcommand === "pull") {
+      const targetHost = process.argv[process.argv.indexOf("pull") + 1];
+      const resolvedTarget = targetHost && !targetHost.startsWith("-") ? targetHost : void 0;
+      const { firebasePull } = await import("./firebaseSync-ON3RZ6KX.js");
+      const result = await firebasePull(resolvedTarget);
+      if (!result) {
+        const hint = resolvedTarget ? `host "${resolvedTarget}"` : "any host";
+        console.error(chalk.red(`  \u2716 No sync data found for ${hint} in Firestore. Run "pyre sync push" from another machine.
+`));
+        process.exit(1);
+      }
+      writeConfig(result.doc.config);
+      saveLocalProfiles(result.doc.profiles);
+      const pulledCount = result.doc.profilesCount;
+      console.log(chalk.green(`  \u2714 Successfully pulled config and ${pulledCount} profile(s) from ${chalk.bold(result.doc.sourceHost)}.`));
+      console.log(chalk.dim(`  Applied to ${getConfigFile()}
+`));
+      return;
+    }
+    console.log(chalk.yellow(`  Unknown subcommand: "${subcommand}". Available: status, push, pull, firebase
+`));
+    return;
+  }
+  const syncDir = opts.syncDir || getDefaultSyncDir();
+  const manifestPath = path.join(syncDir, "sync-manifest.json");
+  const remoteProfilesDir = path.join(syncDir, "profiles");
+  const remoteConfigFile = path.join(syncDir, "config.json");
+  const localProfilesDir = getProfilesDir();
+  const localConfigFile = getConfigFile();
+  console.log(`  Backend:             ${chalk.cyan("Local Folder")}`);
+  console.log(`  Sync Target:         ${chalk.cyan(syncDir)}`);
+  if (subcommand === "status" || !subcommand) {
+    const hasSyncDir = fs.existsSync(syncDir);
+    const hasManifest = fs.existsSync(manifestPath);
+    console.log(`  Local Profiles:      ${chalk.bold(String(fs.existsSync(localProfilesDir) ? fs.readdirSync(localProfilesDir).filter((f) => f.endsWith(".json")).length : 0))}`);
+    console.log(`  Sync Target Exists:  ${hasSyncDir ? chalk.green("YES") : chalk.yellow("NO (will be created on push)")}`);
+    if (hasManifest) {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        console.log(`  Remote Last Updated: ${chalk.green(manifest.lastUpdated)} (from ${chalk.bold(manifest.sourceHost)})`);
+        console.log(`  Remote Profiles:     ${chalk.bold(String(manifest.profilesCount))}`);
+        console.log(`  Remote Checksum:     ${chalk.dim(manifest.checksum)}`);
+      } catch {
+        console.log(chalk.yellow("  Remote manifest corrupted."));
+      }
+    } else {
+      console.log(chalk.dim('  No remote sync bundle detected yet. Run "pyre sync push" to initialize.'));
+    }
+    console.log();
+    return;
+  }
+  if (subcommand === "push") {
+    if (!fs.existsSync(syncDir)) {
+      fs.mkdirSync(syncDir, { recursive: true });
+    }
+    if (!fs.existsSync(remoteProfilesDir)) {
+      fs.mkdirSync(remoteProfilesDir, { recursive: true });
+    }
+    if (fs.existsSync(localConfigFile)) {
+      fs.copyFileSync(localConfigFile, remoteConfigFile);
+    }
+    let profileCount = 0;
+    if (fs.existsSync(localProfilesDir)) {
+      const files = fs.readdirSync(localProfilesDir).filter((f) => f.endsWith(".json"));
+      profileCount = files.length;
+      for (const f of files) {
+        fs.copyFileSync(path.join(localProfilesDir, f), path.join(remoteProfilesDir, f));
+      }
+    }
+    const checksum = computeDirChecksum(remoteProfilesDir);
+    const manifest = {
+      version: 1,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceHost: os.hostname(),
+      checksum,
+      profilesCount: profileCount
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    console.log(chalk.green(`  \u2714 Successfully pushed config and ${profileCount} profile(s) to sync target.`));
+    console.log(`  Checksum: ${chalk.dim(checksum)}  |  Timestamp: ${chalk.dim(manifest.lastUpdated)}
+`);
+    return;
+  }
+  if (subcommand === "pull") {
+    if (!fs.existsSync(manifestPath) || !fs.existsSync(remoteConfigFile)) {
+      console.error(chalk.red(`  \u2716 Error: No sync manifest found at ${syncDir}. Run "pyre sync push" first from another machine.
+`));
+      process.exit(1);
+    }
+    if (fs.existsSync(remoteConfigFile)) {
+      const remoteConfig = JSON.parse(fs.readFileSync(remoteConfigFile, "utf-8"));
+      writeConfig(remoteConfig);
+    }
+    let pulledCount = 0;
+    if (fs.existsSync(remoteProfilesDir)) {
+      if (!fs.existsSync(localProfilesDir)) {
+        fs.mkdirSync(localProfilesDir, { recursive: true });
+      }
+      const files = fs.readdirSync(remoteProfilesDir).filter((f) => f.endsWith(".json"));
+      pulledCount = files.length;
+      for (const f of files) {
+        fs.copyFileSync(path.join(remoteProfilesDir, f), path.join(localProfilesDir, f));
+      }
+    }
+    console.log(chalk.green(`  \u2714 Successfully pulled latest configuration and ${pulledCount} profile(s).`));
+    console.log(chalk.dim(`  Applied to ${localConfigFile}
+`));
+    return;
+  }
+  console.log(chalk.yellow(`  Unknown subcommand: "${subcommand}". Available: status, push, pull, firebase
+`));
+}
+export {
+  runSyncCommand
+};

package/dist/{topoCmd-DU2HHZNH.js → topoCmd-DZ3YS5IL.js}

@@ -1,6 +1,6 @@
 import {
   collectNetwork
-} from "./chunk-GHRDW646.js";
+} from "./chunk-23YWCI3O.js";
 import "./chunk-M73HCQD2.js";
 import "./chunk-VIACN2RU.js";
 import {

package/dist/{watchdogCmd-UF53JPZB.js → watchdogCmd-6GR4UN6B.js}

@@ -1,16 +1,16 @@
+import {
+  collectAll
+} from "./chunk-23YWCI3O.js";
+import "./chunk-M73HCQD2.js";
+import "./chunk-VIACN2RU.js";
 import {
   sendAlert
 } from "./chunk-Z2YV5HKV.js";
+import "./chunk-MZO5QKUR.js";
 import {
   getConfigDir,
   readConfig
-} from "./chunk-53O2RGSL.js";
-import {
-  collectAll
-} from "./chunk-GHRDW646.js";
-import "./chunk-M73HCQD2.js";
-import "./chunk-VIACN2RU.js";
-import "./chunk-MZO5QKUR.js";
+} from "./chunk-QM5L43EK.js";
 
 // src/watchdogCmd.ts
 import fs from "fs";

package/dist/{wizard-TD7BGX6O.js → wizard-JQMQWFAW.js}

@@ -1,7 +1,7 @@
 import {
   CONFIG_FILE,
   writeConfig
-} from "./chunk-53O2RGSL.js";
+} from "./chunk-QM5L43EK.js";
 
 // src/wizard.ts
 import readline from "readline";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "10.1.0",
+  "version": "10.3.0",
   "description": "Cross-platform system monitoring CLI for macOS, Linux, and Windows: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",
@@ -40,7 +40,8 @@
   "license": "MIT",
   "dependencies": {
     "chalk": "^5.3.0",
-    "commander": "^11.1.0"
+    "commander": "^11.1.0",
+    "firebase": "^12.19.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
@@ -48,4 +49,4 @@
     "tsx": "^4.7.0",
     "typescript": "^5.3.3"
   }
-}
+}

package/parity.md

@@ -527,6 +527,8 @@ pyre provides Mac-native security, diagnostics, and ecosystem capabilities that
 * **Kill Confirmation Guard Rails** — Hard confirmation safety check when attempting to terminate protected system PIDs (`launchd`, pyre PID, parent PID).
 * **Accessible Plain-Text Mode** — `--plain`/`--a11y` mode for screen reader compatibility and clean file logging without ANSI noise.
 * **P2P Live Data Streaming & Fleet** — Multi-Mac live streaming with password/TLS auth, HMAC signing, rate-limiting, and IP filtering.
+* **Power User TUI Tools** — Quick-reference overlay (?), fuzzy-search command palette (:), session bookmarks (Shift+M save / M recall), graph zoom ([/]), panel quick-stack (Tab/Shift+Tab), and a footer badge showing active bookmarks, zoom level, and panel history depth.
+* **Live Web Dashboard** — `pyre serve` now serves a Chart.js-based auto-refreshing dashboard at `/` with live CPU, memory, temperature, network, and power sparkline charts.
 
 ---
 

package/src/completions.ts

@@ -8,6 +8,8 @@ _pyre() {
         'info:Display static system overview'
         'doctor:Run system permissions and diagnostic checks'
         'web:Launch web dashboard server'
+        'ui:Launch Activity Monitor UI window'
+        'launch:Launch Activity Monitor UI window'
         'config:Show or reset configuration options'
         'p2p:P2P streaming server or client'
         'ssh:Stream metrics over SSH'
@@ -56,38 +58,38 @@ _pyre_completions() {
     COMPREPLY=()
     cur="\${COMP_WORDS[COMP_CWORD]}"
     prev="\${COMP_WORDS[COMP_CWORD-1]}"
-    commands="live info doctor web config p2p ssh bench completions"
+    commands="live info doctor web ui launch 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
+    case "${prev}" in
         --theme)
-            COMPREPLY=( $(compgen -W "default dracula cyberpunk monochrome nord gruvbox" -- \${cur}) )
+            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}) )
+            COMPREPLY=( $(compgen -W "cpu mem pid user command state threads runtime" -- ${cur}) )
             return 0
             ;;
         --temp-unit)
-            COMPREPLY=( $(compgen -W "c f" -- \${cur}) )
+            COMPREPLY=( $(compgen -W "c f" -- ${cur}) )
             return 0
             ;;
         config)
-            COMPREPLY=( $(compgen -W "show reset" -- \${cur}) )
+            COMPREPLY=( $(compgen -W "show reset" -- ${cur}) )
             return 0
             ;;
         p2p)
-            COMPREPLY=( $(compgen -W "server connect" -- \${cur}) )
+            COMPREPLY=( $(compgen -W "server connect" -- ${cur}) )
             return 0
             ;;
     esac
 
-    if [[ \${cur} == -* ]] ; then
-        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+    if [[ ${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
         return 0
     fi
 
-    COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+    COMPREPLY=( $(compgen -W "${commands}" -- ${cur}) )
 }
 
 complete -F _pyre_completions pyre
@@ -101,6 +103,8 @@ complete -c pyre -n "__fish_use_subcommand" -a live -d "Start interactive live m
 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 ui -d "Launch Activity Monitor UI window"
+complete -c pyre -n "__fish_use_subcommand" -a launch -d "Launch Activity Monitor UI window"
 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"
@@ -121,7 +125,7 @@ export function generatePowerShellCompletions(): string {
   return `# PowerShell completion for pyre
 Register-ArgumentCompleter -Native -CommandName pyre -ScriptBlock {
     param($wordToComplete, $commandAst, $cursorPosition)
-    $commands = @('live', 'check', 'pipe', 'stress', 'ui', 'web', 'ssh', 'fleet', 'bench', 'benchmark', 'anomalies', 'doctor', 'extensions', 'brew', 'update', 'profile', 'config', 'history', 'diff', 'info', 'completions', 'p2p', 'blender', 'prometheus', 'smart', 'replay', 'explain')
+    $commands = @('live', 'check', 'pipe', 'stress', 'ui', 'launch', 'web', 'ssh', 'fleet', 'bench', 'benchmark', 'anomalies', 'doctor', 'extensions', 'brew', 'update', 'profile', 'config', 'history', 'diff', 'info', 'completions', 'p2p', 'blender', 'prometheus', 'smart', 'replay', 'explain')
     $options = @('--json', '--html', '--md', '--csv', '--tsv', '--detailed', '--theme', '--interval', '--once', '--out', '--export-dir', '--log', '--tree', '--sort', '--packets', '--limit', '--alert-cpu', '--alert-temp', '--temp-unit', '--plain', '--help', '--version')
 
     $elements = $commandAst.CommandElements

package/src/easy_features.test.ts

@@ -81,3 +81,152 @@ describe('Cross-Platform Support', () => {
   });
 });
 
+describe('Web and UI Security (LAN exposure & flags)', () => {
+  it('should parse --host, --lan, and --no-lan CLI flags in commander help', async () => {
+    const { execSync } = await import('node:child_process');
+    const help = execSync('node dist/index.js --help', { encoding: 'utf-8' });
+    assert.ok(help.includes('--host <host>'));
+    assert.ok(help.includes('--lan'));
+    assert.ok(help.includes('--no-lan'));
+  });
+
+  it('should bind to localhost and suppress Network URL when --no-lan is passed', async () => {
+    const { spawn } = await import('node:child_process');
+    const child = spawn('node', ['dist/index.js', 'web', '--port', '34881', '--no-lan']);
+    let output = '';
+    await new Promise<void>((resolve) => {
+      child.stdout.on('data', (d) => {
+        output += d.toString();
+        if (output.includes('SSE Stream:')) {
+          resolve();
+        }
+      });
+    });
+    child.kill('SIGINT');
+    assert.ok(output.includes('Network:     Disabled (localhost only for security)'));
+    assert.ok(!output.includes('Accessible on same Wi-Fi / LAN'));
+  });
+
+  it('should expose Network URL when --lan is passed', async () => {
+    const { spawn } = await import('node:child_process');
+    const child = spawn('node', ['dist/index.js', 'web', '--port', '34882', '--lan']);
+    let output = '';
+    await new Promise<void>((resolve) => {
+      child.stdout.on('data', (d) => {
+        output += d.toString();
+        if (output.includes('SSE Stream:')) {
+          resolve();
+        }
+      });
+    });
+    child.kill('SIGINT');
+    assert.ok(output.includes('Accessible on same Wi-Fi / LAN'));
+  });
+});
+
+describe('Pyre-UI Logging and Recording Features', () => {
+  it('should render HTML dashboard containing Logs tab, session recorder, and export dropdown', async () => {
+    const { getDashboardHtml } = await import('./formatters/index.js');
+    const html = getDashboardHtml();
+    assert.ok(html.includes('data-tab="logs"'));
+    assert.ok(html.includes('id="btn-record"'));
+    assert.ok(html.includes('id="export-menu"'));
+    assert.ok(html.includes('id="logs-view"'));
+    assert.ok(html.includes('id="panel-logs"'));
+    assert.ok(html.includes('switchTab(\'logs\')'));
+    assert.ok(html.includes('toggleWebRecording'));
+    assert.ok(html.includes('downloadSnapshot'));
+    assert.ok(html.includes('analyzeAndLog'));
+  });
+
+  it('should register and export all logging REST endpoints and stop cleanly on SIGINT', async () => {
+    const fs = await import('node:fs');
+    const indexSrc = fs.readFileSync(path.join(process.cwd(), 'src/index.ts'), 'utf-8');
+    assert.ok(indexSrc.includes('/api/logging/status'));
+    assert.ok(indexSrc.includes('/api/logging/start'));
+    assert.ok(indexSrc.includes('/api/logging/stop'));
+    assert.ok(indexSrc.includes('/api/logging/history'));
+    assert.ok(indexSrc.includes('/api/logging/download'));
+    assert.ok(indexSrc.includes('/api/export'));
+    assert.ok(indexSrc.includes('stopWebLogging()'));
+
+    const { spawn } = await import('node:child_process');
+    const testPort = '34883';
+    const child = spawn('node', ['dist/index.js', 'web', '--port', testPort, '--no-lan']);
+    let output = '';
+    await new Promise<void>((resolve) => {
+      child.stdout.on('data', (d) => {
+        output += d.toString();
+        if (output.includes('SSE Stream:')) {
+          resolve();
+        }
+      });
+    });
+    assert.ok(output.includes(`running on port ${testPort}`));
+    child.kill('SIGINT');
+  });
+});
+
+describe('Pyre Preferences, Autostart Service, and Settings UI', () => {
+  it('should query service status and installation without crashing', async () => {
+    const { getServiceStatus, isServiceInstalled } = await import('./service.js');
+    const status = getServiceStatus();
+    assert.strictEqual(typeof status.installed, 'boolean');
+    assert.strictEqual(typeof status.platform, 'string');
+    assert.strictEqual(typeof status.serviceLabel, 'string');
+    assert.ok(status.serviceLabel.includes('pyre'));
+    assert.strictEqual(typeof isServiceInstalled(), 'boolean');
+  });
+
+  it('should render HTML dashboard containing Settings modal, tabs, and controls', async () => {
+    const { getDashboardHtml } = await import('./formatters/index.js');
+    const html = getDashboardHtml();
+    assert.ok(html.includes('id="modal-settings"'));
+    assert.ok(html.includes('id="btn-settings"'));
+    assert.ok(html.includes('openSettingsModal'));
+    assert.ok(html.includes('closeSettingsModal'));
+    assert.ok(html.includes('switchSettingsTab'));
+    assert.ok(html.includes('id="spane-general"'));
+    assert.ok(html.includes('id="spane-autostart"'));
+    assert.ok(html.includes('id="spane-alerts"'));
+    assert.ok(html.includes('id="spane-appearance"'));
+    assert.ok(html.includes('id="spane-diagnostics"'));
+    assert.ok(html.includes('toggleAutostartFromUI'));
+    assert.ok(html.includes('sendTestAlertFromUI'));
+    assert.ok(html.includes('runDoctorFromUI'));
+    assert.ok(html.includes('resetConfigFromUI'));
+    assert.ok(html.includes('onDensityChange'));
+    assert.ok(html.includes('density-compact'));
+  });
+
+  it('should read, write, and reset configuration with web preferences', async () => {
+    const { readConfig, writeConfig, resetConfig } = await import('./state/config.js');
+    const initial = readConfig();
+    assert.strictEqual(typeof initial.port, 'number');
+    assert.strictEqual(typeof initial.tableDensity, 'string');
+
+    writeConfig({ tableDensity: 'compact', compact: true, port: 8080 });
+    const updated = readConfig();
+    assert.strictEqual(updated.tableDensity, 'compact');
+    assert.strictEqual(updated.compact, true);
+    assert.strictEqual(updated.port, 8080);
+
+    const reset = resetConfig();
+    assert.strictEqual(reset.tableDensity, 'standard');
+    assert.strictEqual(reset.compact, false);
+    assert.strictEqual(reset.port, 3000);
+  });
+
+  it('should register settings REST endpoints in web server', () => {
+    const indexSrc = fs.readFileSync(path.join(process.cwd(), 'src/index.ts'), 'utf-8');
+    assert.ok(indexSrc.includes('/api/config'));
+    assert.ok(indexSrc.includes('/api/config/reset'));
+    assert.ok(indexSrc.includes('/api/service/status'));
+    assert.ok(indexSrc.includes('/api/service/toggle'));
+    assert.ok(indexSrc.includes('/api/alerts/test'));
+    assert.ok(indexSrc.includes('/api/doctor'));
+  });
+});
+
+
+