Upload 28 files

.gitignore

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+dist-electron/
+*.log
+.DS_Store

FEATURES.md

@@ -0,0 +1,156 @@
+# Computer Auditor — Features & Functionality
+
+Computer Auditor is a desktop **system inspection dashboard** for Windows, built with **Electron** and a **React + TypeScript** UI. It is styled like a **Task Manager / system manager** console: dark panels, dense tables, and icon-only actions with **hover labels** (custom tooltip plus native `title` for accessibility).
+
+The app is designed to **inventory and measure** what is on your machine—storage, processes, services, installed software, network, startup surface, scheduled automation, and optional Windows features—while letting you attach **persistent audit notes** to almost any entity you select.
+
+---
+
+## Platform & runtime
+
+- **Hybrid stack**: **React + TypeScript** UI (renderer), **Electron** main (IPC, notes, shell), and a **Python 3** **FastAPI** backend on **127.0.0.1** (dynamic port) for hot paths: directory listing with recursive sizes, folder totals, large-file scans, processes (`psutil`), drives (`psutil`), system/memory snapshot, environment, and network interfaces. Electron **spawns** `python -m uvicorn main:app` with cwd `backend/` and **kills** the process on quit.
+- **Windows-focused (Node)**: registry software list, services, scheduled tasks, DISM snapshot via **PowerShell** / `dism.exe`; Explorer and `taskkill` for actions.
+- **Python setup**: `cd backend && pip install -r requirements.txt`. Set **`PYTHON_PATH`** if `python` is not on `PATH`.
+- **Electron shell**: full local access from main; renderer is isolated (`contextIsolation`, no Node integration).
+- **Development**: `npm run dev` starts Vite and Electron together. **Production**: `npm run build` then `npm start`.
+
+---
+
+## User interface
+
+- **Minimal layout**: left **navigation rail** (icons + labels), main **toolbar** (section title, global refresh for live system snapshot, status line), scrollable **content**, and a fixed **notes** strip at the bottom.
+- **React Icons (`react-icons/md`)** for every actionable control; **hover** shows a text label via a small tooltip layer.
+- **No emoji** in the product chrome; data-first tables and monospace paths where helpful.
+- **Auto-refresh**: host memory and core **system snapshot** refresh on a short interval while the app is open (complementing manual refresh).
+
+---
+
+## Overview dashboard
+
+- **Host identity**: computer name, signed-in username context from Node.
+- **OS**: platform, kernel release, CPU architecture.
+- **Uptime**: human-readable uptime.
+- **Memory**: used vs total RAM, percentage, bar indicator.
+- **CPU**: logical processor count and model string from `os.cpus()`.
+- **Paths**: home directory and temp directory baselines.
+- **Quick actions** on this screen:
+  - Load **logical volumes** (used/free/total per drive letter).
+  - **Temp directory audit**: approximate total bytes and file count under temp paths (capped walk for safety/performance; may mark truncation when file cap hit).
+
+---
+
+## Storage & volumes
+
+- **Per-volume table**: device id (e.g. `C:`), volume label, used space, free space, total size, utilization bar.
+- **Open in Explorer** for a selected volume root.
+- **Notes** can be keyed to `drive:<letter>` for remediation tracking or change control.
+
+---
+
+## Folders & files
+
+- **Path bar**: type or paste any folder; **list contents** with a full recursive **byte total for every subfolder** (same capped walk as aggregate sizing: stops after a maximum **file count** so huge trees do not run forever). Sizes in the table are shown as **decimal KB** (1 KB = 1024 bytes, two fractional digits). If the cap is hit mid-folder, that row shows a **`+` suffix** (strict lower bound, not complete).
+- **Navigation**: parent shortcut, double-click to enter directories, **open in Explorer** for files or folders.
+- **Large file finder**: scan from a chosen root (defaults to current path) for files above a **minimum size in megabytes**; returns top hits sorted by size (result cap). Useful for reclaiming disk space or spotting bulky artifacts.
+- **Recursive folder size**: totals **bytes and file count** for the current path using a **capped** depth-first walk (stops after a maximum file count so system folders cannot lock the app). Shows whether the result was **truncated** due to the cap.
+- **Copy path**: copies the active folder path to the clipboard for tickets, scripts, or shell use (uses the browser clipboard API when available, otherwise **Electron’s clipboard** via IPC so it still works under `file://` loads).
+- **Notes** attach to `path:<fullPath>` keys.
+
+---
+
+## Processes
+
+- **Live process list** sourced from WMI/CIM (`Win32_Process`): PID, image name, working set (memory), coarse CPU time estimate (kernel + user time converted to seconds—useful for ordering, not a perf chart), and command line when available.
+- **Filter** by name, PID, or command line substring.
+- **End process**: invokes `taskkill /F` after an explicit confirmation. This is a **destructive** action; data in that process may be lost.
+- **Notes** per `proc:<pid>` (PID can change across reboots; notes remain as historical annotations unless you clear them).
+
+---
+
+## Services
+
+- **Windows services** via `Win32_Service`: internal name, display name, state (running/stopped/etc.), start mode (auto/manual/disabled, etc.).
+- **Filtering** across name, display name, and state.
+- **Notes** per `svc:<service name>`.
+
+> The app **does not** start/stop/reconfigure services from the UI (that would require elevated privileges and careful safety). It is **audit and documentation** first.
+
+---
+
+## Installed software
+
+- **Add/remove programs style inventory** from registry hives (64-bit, 32-bit WOW6432Node, and per-user uninstall keys) via PowerShell `Get-ItemProperty`.
+- Columns include **name, version, publisher, install location, estimated size** (when publishers populate it), and raw uninstall string (for your runbooks).
+- **Open install folder** when a path exists.
+- **Notes** per `app:<display name>` (names are not guaranteed unique if vendors collide; use notes carefully).
+
+---
+
+## Network
+
+- **Logical interfaces** from `os.networkInterfaces()`: addresses, address family, internal flag, MAC when present.
+- **Notes** per `net:<interface>:<address>` to document VLANs, VPNs, or static assignments.
+
+---
+
+## Environment
+
+- **Full process environment block** as read by the Electron main process (sorted `KEY=value` lines). Useful for spotting **mis-set PATH**, proxy variables, or deployment tooling flags.
+- **Note** slot `env:all` for global remarks about environment hygiene.
+
+---
+
+## Startup items
+
+- Scans **per-user** and **all-users** Startup shell folders (shortcuts and files). Lists name, type, and allows **Explorer** jump and **path notes** for each entry.
+
+---
+
+## Scheduled tasks
+
+- Enumerates **Task Scheduler** tasks with **name** and **state** via `Get-ScheduledTask` (PowerShell). Handy for **persistence hunting** and automation audits.
+- **Notes** per `task:<task name>`.
+
+---
+
+## Windows optional features (DISM)
+
+- Pulls a **truncated text table** from `dism /Online /Get-Features /Format:Table` for an offline-friendly snapshot of **optional Windows features** state. Large output is clipped to keep IPC responsive; use **note** `features:snippet` to record interpretation or follow-up.
+
+---
+
+## Notes system
+
+- **Persistent JSON** store under the app’s **Electron `userData`** directory (`auditor-notes.json`).
+- **Key/value** model: keys are semantic strings (`path:…`, `proc:…`, `drive:…`, etc.).
+- **Save**, **clear** (delete key), and **reload** from disk.
+- Selecting an entity from a table or drive row sets the **active note key**; the footer editor binds to that key.
+
+---
+
+## Cross-cutting actions
+
+- **Open in Explorer** for paths and volumes (`explorer.exe`).
+- **Open external URL** hook exists in the main process for future deep links (IPC wired).
+- **Status and error lines** in the toolbar for long operations (process list, services, DISM, large scans).
+
+---
+
+## Safety, performance, and limitations
+
+- **Heavy filesystem and process enumeration** run in the **Python** process over **HTTP** (FastAPI + `psutil` + threaded `os.walk` / `os.scandir`), so the Electron **main** thread only proxies `fetch` and stays responsive.
+- **Directory walks** and **large-file scans** use **caps** (max files, max depth, max results) so accidental scans of entire drives do not run unbounded; results may be **partial** or **truncated**—always stated where relevant.
+- **Administrator elevation** is **not** assumed. Some counters (certain services, protected paths) may be incomplete without elevation; DISM feature enumeration may require an elevated session on some systems.
+- **Process kill** and **Explorer open** are the main **active** interventions; everything else is **read/audit**.
+- **Non-Windows** platforms are not the target: several modules will return empty or fallback data if ported without adapters.
+
+---
+
+## How it fits together
+
+1. **Python** (`backend/main.py`): FastAPI on localhost; parallel folder sizing via `ThreadPoolExecutor`; process/disk/network/env data via `psutil`.
+2. **Main process** (`electron/`): starts/stops Python, proxies audit calls with `fetch`, handles notes JSON, PowerShell-only features, Explorer, `taskkill`.
+3. **Preload** exposes **`window.auditor`** (IPC).
+4. **Renderer** (`src/`): React + TypeScript—**no** Python or Node builtins.
+
+This split keeps the UI responsive while still allowing **deep system visibility** appropriate for a personal or IT **audit workstation** tool.

backend/main.py

@@ -0,0 +1,346 @@
+"""
+Computer Auditor — Python backend (FastAPI).
+Hot paths: directory listing with recursive sizes, large-file scan, processes, drives, system, network.
+Binds to 127.0.0.1 only. Started by Electron with: python -m uvicorn main:app --host 127.0.0.1 --port <port>
+"""
+from __future__ import annotations
+
+import os
+import platform
+import socket
+import sys
+import tempfile
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+import psutil
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+MAX_FILES_WALK = 200_000
+
+app = FastAPI(title="Computer Auditor API", version="1.0.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def measure_folder_bytes(root: str) -> tuple[int, int, bool]:
+    """Recursive file byte total under root. Returns (bytes, file_count, truncated)."""
+    total = 0
+    n = 0
+    truncated = False
+    for dirpath, _dirnames, filenames in os.walk(root):
+        for fn in filenames:
+            if n >= MAX_FILES_WALK:
+                return total, n, True
+            fp = os.path.join(dirpath, fn)
+            try:
+                total += os.path.getsize(fp)
+                n += 1
+            except OSError:
+                pass
+    return total, n, False
+
+
+class ListDirBody(BaseModel):
+    path: str
+    max_entries: int = Field(default=800, ge=1, le=5000)
+
+
+class FolderSizeBody(BaseModel):
+    path: str
+
+
+class LargeFilesBody(BaseModel):
+    path: str
+    min_bytes: int = Field(ge=0)
+    max_results: int = Field(default=80, ge=1, le=500)
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.post("/api/list_dir")
+def api_list_dir(body: ListDirBody) -> list[dict[str, Any]]:
+    try:
+        root = os.path.abspath(os.path.normpath(body.path))
+    except Exception as e:
+        raise HTTPException(400, str(e)) from e
+    if not os.path.isdir(root):
+        raise HTTPException(400, "not a directory")
+
+    max_e = min(body.max_entries, 5000)
+    try:
+        with os.scandir(root) as it:
+            raw = list(it)[:max_e]
+    except OSError as e:
+        return [
+            {
+                "name": os.path.basename(root),
+                "fullPath": root,
+                "isDirectory": False,
+                "sizeBytes": 0,
+                "mtimeMs": 0,
+                "error": str(e),
+            }
+        ]
+
+    dirs = [e for e in raw if e.is_dir(follow_symlinks=False)]
+    file_entries = [e for e in raw if not e.is_dir(follow_symlinks=False)]
+
+    out: list[dict[str, Any]] = []
+
+    for e in file_entries:
+        try:
+            st = e.stat(follow_symlinks=False)
+            out.append(
+                {
+                    "name": e.name,
+                    "fullPath": e.path,
+                    "isDirectory": False,
+                    "sizeBytes": st.st_size,
+                    "mtimeMs": int(st.st_mtime * 1000),
+                }
+            )
+        except OSError as ex:
+            out.append(
+                {
+                    "name": e.name,
+                    "fullPath": e.path,
+                    "isDirectory": False,
+                    "sizeBytes": 0,
+                    "mtimeMs": 0,
+                    "error": str(ex),
+                }
+            )
+
+    workers = min(8, max(1, len(dirs)))
+    if dirs:
+        with ThreadPoolExecutor(max_workers=workers) as ex:
+            future_to_ent = {ex.submit(measure_folder_bytes, d.path): d for d in dirs}
+            for fut in as_completed(future_to_ent):
+                d = future_to_ent[fut]
+                try:
+                    bytes_total, _n, truncated = fut.result()
+                    try:
+                        st = os.stat(d.path)
+                        mtime_ms = int(st.st_mtime * 1000)
+                    except OSError:
+                        mtime_ms = 0
+                    out.append(
+                        {
+                            "name": d.name,
+                            "fullPath": d.path,
+                            "isDirectory": True,
+                            "sizeBytes": bytes_total,
+                            "mtimeMs": mtime_ms,
+                            "sizeTruncated": truncated,
+                        }
+                    )
+                except Exception as ex:  # noqa: BLE001
+                    out.append(
+                        {
+                            "name": d.name,
+                            "fullPath": d.path,
+                            "isDirectory": True,
+                            "sizeBytes": 0,
+                            "mtimeMs": 0,
+                            "error": str(ex),
+                        }
+                    )
+
+    out.sort(
+        key=lambda x: (
+            0 if x.get("isDirectory") else 1,
+            -int(x.get("sizeBytes") or 0),
+            str(x.get("name") or ""),
+        )
+    )
+    return out
+
+
+@app.post("/api/folder_size")
+def api_folder_size(body: FolderSizeBody) -> dict[str, Any]:
+    try:
+        root = os.path.abspath(os.path.normpath(body.path))
+    except Exception as e:
+        raise HTTPException(400, str(e)) from e
+    if not os.path.isdir(root):
+        raise HTTPException(400, "not a directory")
+    b, n, t = measure_folder_bytes(root)
+    return {"bytes": b, "files": n, "truncated": t}
+
+
+@app.post("/api/large_files")
+def api_large_files(body: LargeFilesBody) -> list[dict[str, Any]]:
+    try:
+        root = os.path.abspath(os.path.normpath(body.path))
+    except Exception as e:
+        raise HTTPException(400, str(e)) from e
+    if not os.path.isdir(root):
+        raise HTTPException(400, "not a directory")
+
+    cap = min(body.max_results, 500)
+    results: list[dict[str, Any]] = []
+    for dirpath, _dn, filenames in os.walk(root):
+        for fn in filenames:
+            if len(results) >= cap:
+                break
+            fp = os.path.join(dirpath, fn)
+            try:
+                sz = os.path.getsize(fp)
+                if sz >= body.min_bytes:
+                    results.append({"path": fp, "sizeBytes": sz})
+            except OSError:
+                pass
+        if len(results) >= cap:
+            break
+    results.sort(key=lambda x: -x["sizeBytes"])
+    return results[:cap]
+
+
+@app.get("/api/processes")
+def api_processes() -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for p in psutil.process_iter(
+        ["pid", "name", "memory_info", "cpu_times", "cmdline"]
+    ):
+        try:
+            info = p.info
+            mi = info.get("memory_info")
+            rss = mi.rss if mi else 0
+            ct = info.get("cpu_times")
+            cpu_s = None
+            if ct:
+                cpu_s = round(ct.user + ct.system, 2)
+            cmd = info.get("cmdline") or []
+            cmdline = " ".join(cmd) if isinstance(cmd, list) else str(cmd)
+            if len(cmdline) > 8000:
+                cmdline = cmdline[:8000] + "…"
+            rows.append(
+                {
+                    "pid": int(info["pid"]),
+                    "name": str(info.get("name") or ""),
+                    "memoryBytes": int(rss),
+                    "cpuSeconds": cpu_s,
+                    "commandLine": cmdline,
+                }
+            )
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+    return rows
+
+
+@app.get("/api/drives")
+def api_drives() -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    for part in psutil.disk_partitions(all=False):
+        if os.name == "nt" and "cdrom" in (part.opts or "").lower():
+            continue
+        try:
+            u = psutil.disk_usage(part.mountpoint)
+            dev = part.device.rstrip("\\/")
+            out.append(
+                {
+                    "letter": dev if dev else part.mountpoint,
+                    "mount": part.mountpoint,
+                    "label": part.fstype or "",
+                    "totalBytes": int(u.total),
+                    "freeBytes": int(u.free),
+                    "usedBytes": int(u.used),
+                }
+            )
+        except OSError:
+            continue
+    return out
+
+
+@app.get("/api/system")
+def api_system() -> dict[str, Any]:
+    vm = psutil.virtual_memory()
+    boot = psutil.boot_time()
+    try:
+        user = os.getlogin()
+    except OSError:
+        user = os.environ.get("USERNAME", os.environ.get("USER", ""))
+    cpus = os.cpu_count() or 1
+    model = ""
+    if platform.system() == "Windows":
+        try:
+            import ctypes  # noqa: PLC0415
+
+            buf = ctypes.create_unicode_buffer(256)
+            if ctypes.windll.kernel32.GetEnvironmentVariableW("PROCESSOR_IDENTIFIER", buf, 256):
+                model = buf.value
+        except Exception:  # noqa: BLE001
+            model = platform.processor() or ""
+    else:
+        model = platform.processor() or ""
+
+    return {
+        "hostname": socket.gethostname(),
+        "platform": sys.platform,
+        "release": platform.release(),
+        "arch": platform.machine(),
+        "uptimeSec": time.time() - boot,
+        "totalMem": int(vm.total),
+        "freeMem": int(vm.available),
+        "cpuModel": model,
+        "cpuCount": cpus,
+        "load1": 0.0,
+        "load5": 0.0,
+        "load15": 0.0,
+        "userInfo": user,
+        "homedir": str(os.path.expanduser("~")),
+        "tmpdir": tempfile.gettempdir(),
+    }
+
+
+@app.get("/api/network")
+def api_network() -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    link_fam = getattr(psutil, "AF_LINK", None)
+    for name, addrs in psutil.net_if_addrs().items():
+        for a in addrs:
+            if a.family == socket.AF_INET:
+                fam_s = "IPv4"
+            elif a.family == socket.AF_INET6:
+                fam_s = "IPv6"
+            elif link_fam is not None and a.family == link_fam:
+                fam_s = "MAC"
+            else:
+                fam_s = str(a.family)
+            addr = a.address
+            internal = addr.startswith("127.") or addr == "::1"
+            mac = addr if fam_s == "MAC" else None
+            rows.append(
+                {
+                    "name": name,
+                    "address": addr,
+                    "family": fam_s,
+                    "internal": internal,
+                    "mac": mac,
+                }
+            )
+    return rows
+
+
+@app.get("/api/env")
+def api_env() -> dict[str, str]:
+    return dict(os.environ)
+
+
+if __name__ == "__main__":
+    import uvicorn  # noqa: PLC0415
+
+    port = int(os.environ.get("AUDITOR_PY_PORT", "54789"))
+    uvicorn.run(app, host="127.0.0.1", port=port, log_level="warning")

backend/requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.115.0
+uvicorn[standard]>=0.32.0
+psutil>=6.0.0
+pydantic>=2.0.0

dist-electron/audit.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDrivesWin = getDrivesWin;
+exports.listDirectory = listDirectory;
+exports.computeFolderSize = computeFolderSize;
+exports.findLargeFiles = findLargeFiles;
+exports.getProcessesWin = getProcessesWin;
+exports.getServicesWin = getServicesWin;
+exports.getInstalledPrograms = getInstalledPrograms;
+exports.getSystemSnapshot = getSystemSnapshot;
+exports.getNetworkInterfaces = getNetworkInterfaces;
+exports.getEnvSnapshot = getEnvSnapshot;
+exports.getStartupFolders = getStartupFolders;
+exports.getTempAudit = getTempAudit;
+exports.getScheduledTasksSummary = getScheduledTasksSummary;
+exports.openPathInExplorer = openPathInExplorer;
+exports.killProcess = killProcess;
+exports.getWindowsFeaturesSnippet = getWindowsFeaturesSnippet;
+/**
+ * Audit logic: hot paths (filesystem, processes, drives, system, network, env) → Python FastAPI.
+ * Windows-specific shell/registry work stays in Node.
+ */
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const pythonBackend_1 = require("./pythonBackend");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function resolveSafePath(input) {
+    const normalized = path.normalize(input);
+    return path.resolve(normalized);
+}
+async function getDrivesWin() {
+    return (0, pythonBackend_1.pyGet)('/api/drives');
+}
+async function listDirectory(dirPath, options = {}) {
+    const root = resolveSafePath(dirPath);
+    return (0, pythonBackend_1.pyPost)('/api/list_dir', {
+        path: root,
+        max_entries: options.maxEntries ?? 800,
+    });
+}
+async function computeFolderSize(dirPath) {
+    return (0, pythonBackend_1.pyPost)('/api/folder_size', {
+        path: resolveSafePath(dirPath),
+    });
+}
+async function findLargeFiles(rootPath, minBytes, maxResults) {
+    return (0, pythonBackend_1.pyPost)('/api/large_files', {
+        path: resolveSafePath(rootPath),
+        min_bytes: minBytes,
+        max_results: maxResults,
+    });
+}
+async function getProcessesWin() {
+    return (0, pythonBackend_1.pyGet)('/api/processes');
+}
+async function getServicesWin() {
+    const script = `
+    Get-CimInstance Win32_Service | Select-Object Name,DisplayName,State,StartMode | ConvertTo-Json -Compress
+  `;
+    try {
+        const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], { windowsHide: true, maxBuffer: 20 * 1024 * 1024, timeout: 120_000 });
+        const raw = JSON.parse(stdout.trim() || '[]');
+        const arr = Array.isArray(raw) ? raw : [raw];
+        return arr.map((s) => ({
+            name: String(s.Name ?? ''),
+            displayName: String(s.DisplayName ?? ''),
+            state: String(s.State ?? ''),
+            startType: String(s.StartMode ?? ''),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function getInstalledPrograms() {
+    const script = `
+    $paths = @(
+      'HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+      'HKLM:\\Software\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+      'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*'
+    )
+    Get-ItemProperty $paths -ErrorAction SilentlyContinue |
+      Where-Object { $_.DisplayName } |
+      Select-Object DisplayName, DisplayVersion, Publisher, InstallLocation, UninstallString, EstimatedSize |
+      ConvertTo-Json -Compress -Depth 4
+  `;
+    try {
+        const stdout = (0, node_child_process_1.execFileSync)('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], { encoding: 'utf8', windowsHide: true, maxBuffer: 50 * 1024 * 1024 });
+        const raw = JSON.parse(stdout.trim() || '[]');
+        const arr = Array.isArray(raw) ? raw : [raw];
+        const apps = arr.map((r) => ({
+            name: String(r.DisplayName ?? ''),
+            version: String(r.DisplayVersion ?? ''),
+            publisher: String(r.Publisher ?? ''),
+            installLocation: String(r.InstallLocation ?? ''),
+            uninstallString: String(r.UninstallString ?? ''),
+            estimatedSizeKb: Number(r.EstimatedSize) || 0,
+        }));
+        const seen = new Set();
+        return apps
+            .filter((a) => {
+            const k = a.name.toLowerCase();
+            if (!k || seen.has(k))
+                return false;
+            seen.add(k);
+            return true;
+        })
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    catch {
+        return [];
+    }
+}
+async function getSystemSnapshot() {
+    return (0, pythonBackend_1.pyGet)('/api/system');
+}
+async function getNetworkInterfaces() {
+    return (0, pythonBackend_1.pyGet)('/api/network');
+}
+async function getEnvSnapshot(keys) {
+    const all = await (0, pythonBackend_1.pyGet)('/api/env');
+    if (!keys?.length)
+        return all;
+    const out = {};
+    for (const k of keys) {
+        const v = all[k];
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+async function getStartupFolders() {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
+    const programData = process.env.PROGRAMDATA ?? 'C:\\ProgramData';
+    const folders = [
+        path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup'),
+        path.join(programData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'StartUp'),
+    ];
+    const result = [];
+    for (const f of folders) {
+        const entries = await listDirectory(f, { maxEntries: 200 });
+        result.push({ path: f, entries });
+    }
+    return result;
+}
+async function getTempAudit() {
+    const dirs = [os.tmpdir(), path.join(os.tmpdir(), '..', 'Temp')].map((p) => path.normalize(p));
+    const uniq = [...new Set(dirs)];
+    const out = [];
+    for (const d of uniq) {
+        try {
+            const r = await computeFolderSize(d);
+            out.push({ path: d, ...r });
+        }
+        catch {
+            out.push({ path: d, bytes: 0, files: 0, truncated: false });
+        }
+    }
+    return out;
+}
+async function getScheduledTasksSummary() {
+    const script = `
+    Get-ScheduledTask | Select-Object TaskName,State | ConvertTo-Json -Compress
+  `;
+    try {
+        const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], { windowsHide: true, maxBuffer: 20 * 1024 * 1024, timeout: 120_000 });
+        const raw = JSON.parse(stdout.trim() || '[]');
+        const arr = Array.isArray(raw) ? raw : [raw];
+        return arr.map((t) => ({
+            name: String(t.TaskName ?? ''),
+            state: String(t.State ?? ''),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+async function openPathInExplorer(p) {
+    const resolved = resolveSafePath(p);
+    await execFileAsync('explorer.exe', [resolved], { windowsHide: true });
+}
+function killProcess(pid) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, node_child_process_1.spawn)('taskkill', ['/PID', String(pid), '/F'], { windowsHide: true });
+        proc.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`taskkill exit ${code}`))));
+        proc.on('error', reject);
+    });
+}
+async function getWindowsFeaturesSnippet() {
+    try {
+        const { stdout } = await execFileAsync('dism.exe', ['/Online', '/Get-Features', '/Format:Table'], { windowsHide: true, maxBuffer: 5 * 1024 * 1024, timeout: 60_000 });
+        return stdout.slice(0, 120_000);
+    }
+    catch (e) {
+        return String(e.message);
+    }
+}

dist-electron/fsWorker.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Runs in a worker thread (never blocks the Electron main process).
+ * Keep walk caps in sync with audit.ts.
+ */
+const node_worker_threads_1 = require("node:worker_threads");
+const fssync = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const FOLDER_WALK_MAX_FILES = 200_000;
+function resolveSafePath(input) {
+    return path.resolve(path.normalize(input));
+}
+function measureFolderTree(rootDir, maxFiles = FOLDER_WALK_MAX_FILES) {
+    const root = resolveSafePath(rootDir);
+    let bytes = 0;
+    let files = 0;
+    const walk = (d) => {
+        let list;
+        try {
+            list = fssync.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        for (const ent of list) {
+            if (files >= maxFiles)
+                return true;
+            const p = path.join(d, ent.name);
+            try {
+                if (ent.isDirectory()) {
+                    if (walk(p))
+                        return true;
+                }
+                else {
+                    bytes += fssync.statSync(p).size;
+                    files++;
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return false;
+    };
+    const truncated = walk(root);
+    return { bytes, files, truncated };
+}
+function findLargeFilesSync(rootPath, minBytes, maxResults) {
+    const root = resolveSafePath(rootPath);
+    const results = [];
+    const cap = Math.min(maxResults, 500);
+    const walk = (d) => {
+        if (results.length >= cap)
+            return;
+        let list;
+        try {
+            list = fssync.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of list) {
+            if (results.length >= cap)
+                return;
+            const p = path.join(d, ent.name);
+            try {
+                if (ent.isDirectory()) {
+                    walk(p);
+                }
+                else {
+                    const st = fssync.statSync(p);
+                    if (st.size >= minBytes) {
+                        results.push({ path: p, sizeBytes: st.size });
+                    }
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    };
+    walk(root);
+    results.sort((a, b) => b.sizeBytes - a.sizeBytes);
+    return results.slice(0, cap);
+}
+if (!node_worker_threads_1.isMainThread && node_worker_threads_1.parentPort) {
+    node_worker_threads_1.parentPort.on('message', (msg) => {
+        try {
+            if (msg.kind === 'large') {
+                const largeResults = findLargeFilesSync(msg.root, msg.minBytes, msg.maxResults);
+                node_worker_threads_1.parentPort.postMessage({ id: msg.id, ok: true, largeResults });
+            }
+            else {
+                const { bytes, files, truncated } = measureFolderTree(msg.root);
+                node_worker_threads_1.parentPort.postMessage({ id: msg.id, ok: true, bytes, files, truncated });
+            }
+        }
+        catch (e) {
+            node_worker_threads_1.parentPort.postMessage({
+                id: msg.id,
+                ok: false,
+                error: String(e.message),
+            });
+        }
+    });
+}

dist-electron/main.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const path = __importStar(require("node:path"));
+const fssync = __importStar(require("node:fs"));
+const audit_1 = require("./audit");
+const pythonBackend_1 = require("./pythonBackend");
+const isDev = !!process.env.VITE_DEV_SERVER_URL;
+function notesPath() {
+    return path.join(electron_1.app.getPath('userData'), 'auditor-notes.json');
+}
+function loadNotes() {
+    try {
+        const raw = fssync.readFileSync(notesPath(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function saveNotes(n) {
+    fssync.mkdirSync(path.dirname(notesPath()), { recursive: true });
+    fssync.writeFileSync(notesPath(), JSON.stringify(n, null, 2), 'utf8');
+}
+function createWindow() {
+    const win = new electron_1.BrowserWindow({
+        width: 1280,
+        height: 800,
+        minWidth: 960,
+        minHeight: 640,
+        backgroundColor: '#0d0f12',
+        titleBarStyle: process.platform === 'darwin' ? 'hiddenInset' : 'default',
+        webPreferences: {
+            preload: path.join(__dirname, 'preload.js'),
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: false,
+        },
+    });
+    if (isDev) {
+        win.loadURL(process.env.VITE_DEV_SERVER_URL);
+    }
+    else {
+        win.loadFile(path.join(__dirname, '../dist/index.html'));
+    }
+}
+electron_1.app.whenReady().then(async () => {
+    try {
+        await (0, pythonBackend_1.startPythonBackend)();
+    }
+    catch (e) {
+        electron_1.dialog.showErrorBox('Python backend required', `${String(e)}\n\nInstall: cd backend && pip install -r requirements.txt`);
+        electron_1.app.quit();
+        return;
+    }
+    electron_1.ipcMain.handle('audit:drives', () => (0, audit_1.getDrivesWin)());
+    electron_1.ipcMain.handle('audit:listDir', (_e, dirPath, opts) => (0, audit_1.listDirectory)(dirPath, opts ?? {}));
+    electron_1.ipcMain.handle('audit:folderSize', (_e, dirPath) => (0, audit_1.computeFolderSize)(dirPath));
+    electron_1.ipcMain.handle('audit:largeFiles', (_e, rootPath, minBytes, maxResults) => (0, audit_1.findLargeFiles)(rootPath, minBytes, maxResults));
+    electron_1.ipcMain.handle('audit:processes', () => (0, audit_1.getProcessesWin)());
+    electron_1.ipcMain.handle('audit:services', () => (0, audit_1.getServicesWin)());
+    electron_1.ipcMain.handle('audit:installed', () => (0, audit_1.getInstalledPrograms)());
+    electron_1.ipcMain.handle('audit:system', () => (0, audit_1.getSystemSnapshot)());
+    electron_1.ipcMain.handle('audit:network', () => (0, audit_1.getNetworkInterfaces)());
+    electron_1.ipcMain.handle('audit:env', (_e, keys) => (0, audit_1.getEnvSnapshot)(keys));
+    electron_1.ipcMain.handle('audit:startup', () => (0, audit_1.getStartupFolders)());
+    electron_1.ipcMain.handle('audit:temp', () => (0, audit_1.getTempAudit)());
+    electron_1.ipcMain.handle('audit:tasks', () => (0, audit_1.getScheduledTasksSummary)());
+    electron_1.ipcMain.handle('audit:features', () => (0, audit_1.getWindowsFeaturesSnippet)());
+    electron_1.ipcMain.handle('audit:openExplorer', (_e, p) => (0, audit_1.openPathInExplorer)(p));
+    electron_1.ipcMain.handle('audit:killProcess', (_e, pid) => (0, audit_1.killProcess)(pid));
+    electron_1.ipcMain.handle('audit:openExternal', (_e, url) => electron_1.shell.openExternal(url));
+    electron_1.ipcMain.handle('clipboard:writeText', (_e, text) => {
+        electron_1.clipboard.writeText(text);
+    });
+    electron_1.ipcMain.handle('notes:getAll', () => loadNotes());
+    electron_1.ipcMain.handle('notes:set', (_e, key, value) => {
+        const all = loadNotes();
+        if (value.trim() === '')
+            delete all[key];
+        else
+            all[key] = value;
+        saveNotes(all);
+        return all;
+    });
+    electron_1.ipcMain.handle('notes:delete', (_e, key) => {
+        const all = loadNotes();
+        delete all[key];
+        saveNotes(all);
+        return all;
+    });
+    createWindow();
+    electron_1.app.on('activate', () => {
+        if (electron_1.BrowserWindow.getAllWindows().length === 0)
+            createWindow();
+    });
+});
+electron_1.app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin')
+        electron_1.app.quit();
+});
+electron_1.app.on('before-quit', () => {
+    (0, pythonBackend_1.stopPythonBackend)();
+});

dist-electron/measureWorker.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureFolderAsync = measureFolderAsync;
+exports.findLargeFilesAsync = findLargeFilesAsync;
+exports.terminateMeasureWorkers = terminateMeasureWorkers;
+/**
+ * Offloads filesystem walks to worker threads so the Electron main process stays responsive.
+ * Pool of 2 workers balances throughput vs disk contention.
+ */
+const node_worker_threads_1 = require("node:worker_threads");
+const path = __importStar(require("node:path"));
+const POOL_SIZE = 2;
+let pool = null;
+let seq = 0;
+const pendingMeasure = new Map();
+const pendingLarge = new Map();
+function workerScriptPath() {
+    return path.join(__dirname, 'fsWorker.js');
+}
+function rejectAllPending(err) {
+    for (const [, p] of pendingMeasure)
+        p.reject(err);
+    for (const [, p] of pendingLarge)
+        p.reject(err);
+    pendingMeasure.clear();
+    pendingLarge.clear();
+}
+function ensurePool() {
+    if (pool)
+        return pool;
+    pool = [];
+    for (let i = 0; i < POOL_SIZE; i++) {
+        const w = new node_worker_threads_1.Worker(workerScriptPath());
+        w.on('message', (msg) => {
+            if (pendingMeasure.has(msg.id)) {
+                const p = pendingMeasure.get(msg.id);
+                pendingMeasure.delete(msg.id);
+                if (!msg.ok) {
+                    p.reject(new Error(msg.error ?? 'measure failed'));
+                    return;
+                }
+                if (msg.bytes !== undefined && msg.files !== undefined && msg.truncated !== undefined) {
+                    p.resolve({ bytes: msg.bytes, files: msg.files, truncated: msg.truncated });
+                }
+                else {
+                    p.reject(new Error('invalid measure response'));
+                }
+                return;
+            }
+            if (pendingLarge.has(msg.id)) {
+                const p = pendingLarge.get(msg.id);
+                pendingLarge.delete(msg.id);
+                if (!msg.ok) {
+                    p.reject(new Error(msg.error ?? 'large file scan failed'));
+                    return;
+                }
+                if (msg.largeResults !== undefined) {
+                    p.resolve(msg.largeResults);
+                }
+                else {
+                    p.reject(new Error('invalid large-file response'));
+                }
+            }
+        });
+        w.on('error', (err) => {
+            rejectAllPending(err);
+        });
+        pool.push(w);
+    }
+    return pool;
+}
+function measureFolderAsync(absPath) {
+    const workers = ensurePool();
+    const id = ++seq;
+    return new Promise((resolve, reject) => {
+        pendingMeasure.set(id, { resolve, reject });
+        const w = workers[id % POOL_SIZE];
+        w.postMessage({ id, kind: 'measure', root: absPath });
+    });
+}
+function findLargeFilesAsync(root, minBytes, maxResults) {
+    const workers = ensurePool();
+    const id = ++seq;
+    return new Promise((resolve, reject) => {
+        pendingLarge.set(id, { resolve, reject });
+        const w = workers[id % POOL_SIZE];
+        w.postMessage({ id, kind: 'large', root, minBytes, maxResults });
+    });
+}
+function terminateMeasureWorkers() {
+    if (!pool)
+        return;
+    for (const w of pool) {
+        try {
+            w.terminate();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    pool = null;
+    pendingMeasure.clear();
+    pendingLarge.clear();
+}

dist-electron/preload.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const api = {
+    drives: () => electron_1.ipcRenderer.invoke('audit:drives'),
+    listDir: (dirPath, opts) => electron_1.ipcRenderer.invoke('audit:listDir', dirPath, opts),
+    folderSize: (dirPath) => electron_1.ipcRenderer.invoke('audit:folderSize', dirPath),
+    largeFiles: (rootPath, minBytes, maxResults) => electron_1.ipcRenderer.invoke('audit:largeFiles', rootPath, minBytes, maxResults),
+    processes: () => electron_1.ipcRenderer.invoke('audit:processes'),
+    services: () => electron_1.ipcRenderer.invoke('audit:services'),
+    installed: () => electron_1.ipcRenderer.invoke('audit:installed'),
+    system: () => electron_1.ipcRenderer.invoke('audit:system'),
+    network: () => electron_1.ipcRenderer.invoke('audit:network'),
+    env: (keys) => electron_1.ipcRenderer.invoke('audit:env', keys),
+    startup: () => electron_1.ipcRenderer.invoke('audit:startup'),
+    temp: () => electron_1.ipcRenderer.invoke('audit:temp'),
+    tasks: () => electron_1.ipcRenderer.invoke('audit:tasks'),
+    features: () => electron_1.ipcRenderer.invoke('audit:features'),
+    openExplorer: (p) => electron_1.ipcRenderer.invoke('audit:openExplorer', p),
+    killProcess: (pid) => electron_1.ipcRenderer.invoke('audit:killProcess', pid),
+    openExternal: (url) => electron_1.ipcRenderer.invoke('audit:openExternal', url),
+    clipboardWriteText: (text) => electron_1.ipcRenderer.invoke('clipboard:writeText', text),
+    notesGetAll: () => electron_1.ipcRenderer.invoke('notes:getAll'),
+    notesSet: (key, value) => electron_1.ipcRenderer.invoke('notes:set', key, value),
+    notesDelete: (key) => electron_1.ipcRenderer.invoke('notes:delete', key),
+};
+electron_1.contextBridge.exposeInMainWorld('auditor', api);

dist-electron/pythonBackend.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPythonBaseUrl = getPythonBaseUrl;
+exports.startPythonBackend = startPythonBackend;
+exports.stopPythonBackend = stopPythonBackend;
+exports.pyGet = pyGet;
+exports.pyPost = pyPost;
+/**
+ * Spawns the FastAPI Python backend and exposes HTTP helpers for the main process.
+ * Python handles hot paths (filesystem sizes, processes, drives, system, network, env).
+ */
+const node_child_process_1 = require("node:child_process");
+const net = __importStar(require("node:net"));
+const path = __importStar(require("node:path"));
+let child = null;
+let baseUrl = '';
+function getPythonBaseUrl() {
+    return baseUrl;
+}
+function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const s = net.createServer();
+        s.listen(0, '127.0.0.1', () => {
+            const a = s.address();
+            const p = typeof a === 'object' && a ? a.port : 0;
+            s.close(() => resolve(p));
+        });
+        s.on('error', reject);
+    });
+}
+async function waitForHealth(port, timeoutMs) {
+    const url = `http://127.0.0.1:${port}/health`;
+    const t0 = Date.now();
+    while (Date.now() - t0 < timeoutMs) {
+        try {
+            const r = await fetch(url);
+            if (r.ok)
+                return;
+        }
+        catch {
+            /* retry */
+        }
+        await new Promise((r) => setTimeout(r, 120));
+    }
+    throw new Error(`Python backend did not respond at ${url}`);
+}
+async function startPythonBackend() {
+    const port = await getFreePort();
+    const backendDir = path.join(__dirname, '..', 'backend');
+    const py = process.env.PYTHON_PATH ?? (process.platform === 'win32' ? 'python' : 'python3');
+    child = (0, node_child_process_1.spawn)(py, ['-m', 'uvicorn', 'main:app', '--host', '127.0.0.1', '--port', String(port), '--log-level', 'warning'], {
+        cwd: backendDir,
+        env: { ...process.env, AUDITOR_PY_PORT: String(port) },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    });
+    let stderrBuf = '';
+    child.stderr?.on('data', (d) => {
+        stderrBuf += d.toString();
+        if (stderrBuf.length > 8000)
+            stderrBuf = stderrBuf.slice(-4000);
+    });
+    await new Promise((resolve, reject) => {
+        const fail = (err) => {
+            try {
+                child?.kill();
+            }
+            catch {
+                /* ignore */
+            }
+            reject(err);
+        };
+        const t = setTimeout(() => {
+            fail(new Error(`Python backend startup timed out. Install: cd backend && pip install -r requirements.txt\n${stderrBuf}`));
+        }, 25_000);
+        child.once('error', (err) => {
+            clearTimeout(t);
+            fail(err instanceof Error ? err : new Error(String(err)));
+        });
+        waitForHealth(port, 24_000)
+            .then(() => {
+            clearTimeout(t);
+            resolve();
+        })
+            .catch((e) => {
+            clearTimeout(t);
+            fail(e instanceof Error ? e : new Error(String(e)));
+        });
+    });
+    baseUrl = `http://127.0.0.1:${port}`;
+}
+function stopPythonBackend() {
+    if (child) {
+        try {
+            child.kill();
+        }
+        catch {
+            /* ignore */
+        }
+        child = null;
+    }
+    baseUrl = '';
+}
+async function pyGet(pathname) {
+    const r = await fetch(`${baseUrl}${pathname}`);
+    if (!r.ok) {
+        const t = await r.text();
+        throw new Error(t || r.statusText);
+    }
+    return r.json();
+}
+async function pyPost(pathname, body) {
+    const r = await fetch(`${baseUrl}${pathname}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!r.ok) {
+        const t = await r.text();
+        throw new Error(t || r.statusText);
+    }
+    return r.json();
+}

electron/audit.ts

@@ -0,0 +1,281 @@
+/**
+ * Audit logic: hot paths (filesystem, processes, drives, system, network, env) → Python FastAPI.
+ * Windows-specific shell/registry work stays in Node.
+ */
+import * as path from 'node:path'
+import * as os from 'node:os'
+import { execFile, execFileSync, spawn } from 'node:child_process'
+import { promisify } from 'node:util'
+import { pyGet, pyPost } from './pythonBackend'
+
+const execFileAsync = promisify(execFile)
+
+export interface DriveInfo {
+  letter: string
+  mount: string
+  label: string
+  totalBytes: number
+  freeBytes: number
+  usedBytes: number
+}
+
+export interface DirEntry {
+  name: string
+  fullPath: string
+  isDirectory: boolean
+  sizeBytes: number
+  mtimeMs: number
+  error?: string
+  sizeTruncated?: boolean
+}
+
+export interface ProcessRow {
+  pid: number
+  name: string
+  memoryBytes: number
+  cpuSeconds?: number
+  commandLine?: string
+}
+
+export interface ServiceRow {
+  name: string
+  displayName: string
+  state: string
+  startType: string
+}
+
+export interface InstalledApp {
+  name: string
+  version: string
+  publisher: string
+  installLocation: string
+  uninstallString: string
+  estimatedSizeKb: number
+}
+
+export interface NetworkRow {
+  name: string
+  address: string
+  family: string
+  internal: boolean
+  mac?: string
+}
+
+function resolveSafePath(input: string): string {
+  const normalized = path.normalize(input)
+  return path.resolve(normalized)
+}
+
+export async function getDrivesWin(): Promise<DriveInfo[]> {
+  return pyGet<DriveInfo[]>('/api/drives')
+}
+
+export async function listDirectory(
+  dirPath: string,
+  options: { maxEntries?: number } = {}
+): Promise<DirEntry[]> {
+  const root = resolveSafePath(dirPath)
+  return pyPost<DirEntry[]>('/api/list_dir', {
+    path: root,
+    max_entries: options.maxEntries ?? 800,
+  })
+}
+
+export async function computeFolderSize(dirPath: string): Promise<{ bytes: number; files: number; truncated: boolean }> {
+  return pyPost<{ bytes: number; files: number; truncated: boolean }>('/api/folder_size', {
+    path: resolveSafePath(dirPath),
+  })
+}
+
+export async function findLargeFiles(
+  rootPath: string,
+  minBytes: number,
+  maxResults: number
+): Promise<{ path: string; sizeBytes: number }[]> {
+  return pyPost<{ path: string; sizeBytes: number }[]>('/api/large_files', {
+    path: resolveSafePath(rootPath),
+    min_bytes: minBytes,
+    max_results: maxResults,
+  })
+}
+
+export async function getProcessesWin(): Promise<ProcessRow[]> {
+  return pyGet<ProcessRow[]>('/api/processes')
+}
+
+export async function getServicesWin(): Promise<ServiceRow[]> {
+  const script = `
+    Get-CimInstance Win32_Service | Select-Object Name,DisplayName,State,StartMode | ConvertTo-Json -Compress
+  `
+  try {
+    const { stdout } = await execFileAsync(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-Command', script],
+      { windowsHide: true, maxBuffer: 20 * 1024 * 1024, timeout: 120_000 }
+    )
+    const raw = JSON.parse(stdout.trim() || '[]')
+    const arr = Array.isArray(raw) ? raw : [raw]
+    return arr.map((s: Record<string, unknown>) => ({
+      name: String(s.Name ?? ''),
+      displayName: String(s.DisplayName ?? ''),
+      state: String(s.State ?? ''),
+      startType: String(s.StartMode ?? ''),
+    }))
+  } catch {
+    return []
+  }
+}
+
+export function getInstalledPrograms(): InstalledApp[] {
+  const script = `
+    $paths = @(
+      'HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+      'HKLM:\\Software\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+      'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*'
+    )
+    Get-ItemProperty $paths -ErrorAction SilentlyContinue |
+      Where-Object { $_.DisplayName } |
+      Select-Object DisplayName, DisplayVersion, Publisher, InstallLocation, UninstallString, EstimatedSize |
+      ConvertTo-Json -Compress -Depth 4
+  `
+  try {
+    const stdout = execFileSync(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-Command', script],
+      { encoding: 'utf8', windowsHide: true, maxBuffer: 50 * 1024 * 1024 }
+    )
+    const raw = JSON.parse(stdout.trim() || '[]')
+    const arr = Array.isArray(raw) ? raw : [raw]
+    const apps: InstalledApp[] = arr.map((r: Record<string, unknown>) => ({
+      name: String(r.DisplayName ?? ''),
+      version: String(r.DisplayVersion ?? ''),
+      publisher: String(r.Publisher ?? ''),
+      installLocation: String(r.InstallLocation ?? ''),
+      uninstallString: String(r.UninstallString ?? ''),
+      estimatedSizeKb: Number(r.EstimatedSize) || 0,
+    }))
+    const seen = new Set<string>()
+    return apps
+      .filter((a) => {
+        const k = a.name.toLowerCase()
+        if (!k || seen.has(k)) return false
+        seen.add(k)
+        return true
+      })
+      .sort((a, b) => a.name.localeCompare(b.name))
+  } catch {
+    return []
+  }
+}
+
+export async function getSystemSnapshot() {
+  return pyGet<{
+    hostname: string
+    platform: string
+    release: string
+    arch: string
+    uptimeSec: number
+    totalMem: number
+    freeMem: number
+    cpuModel: string
+    cpuCount: number
+    load1: number
+    load5: number
+    load15: number
+    userInfo: string
+    homedir: string
+    tmpdir: string
+  }>('/api/system')
+}
+
+export async function getNetworkInterfaces(): Promise<NetworkRow[]> {
+  return pyGet<NetworkRow[]>('/api/network')
+}
+
+export async function getEnvSnapshot(keys?: string[]): Promise<Record<string, string>> {
+  const all = await pyGet<Record<string, string>>('/api/env')
+  if (!keys?.length) return all
+  const out: Record<string, string> = {}
+  for (const k of keys) {
+    const v = all[k]
+    if (v !== undefined) out[k] = v
+  }
+  return out
+}
+
+export async function getStartupFolders(): Promise<{ path: string; entries: DirEntry[] }[]> {
+  const appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming')
+  const programData = process.env.PROGRAMDATA ?? 'C:\\ProgramData'
+  const folders = [
+    path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup'),
+    path.join(programData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'StartUp'),
+  ]
+  const result: { path: string; entries: DirEntry[] }[] = []
+  for (const f of folders) {
+    const entries = await listDirectory(f, { maxEntries: 200 })
+    result.push({ path: f, entries })
+  }
+  return result
+}
+
+export async function getTempAudit(): Promise<{ path: string; bytes: number; files: number; truncated: boolean }[]> {
+  const dirs = [os.tmpdir(), path.join(os.tmpdir(), '..', 'Temp')].map((p) => path.normalize(p))
+  const uniq = [...new Set(dirs)]
+  const out: { path: string; bytes: number; files: number; truncated: boolean }[] = []
+  for (const d of uniq) {
+    try {
+      const r = await computeFolderSize(d)
+      out.push({ path: d, ...r })
+    } catch {
+      out.push({ path: d, bytes: 0, files: 0, truncated: false })
+    }
+  }
+  return out
+}
+
+export async function getScheduledTasksSummary(): Promise<{ name: string; state: string }[]> {
+  const script = `
+    Get-ScheduledTask | Select-Object TaskName,State | ConvertTo-Json -Compress
+  `
+  try {
+    const { stdout } = await execFileAsync(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-Command', script],
+      { windowsHide: true, maxBuffer: 20 * 1024 * 1024, timeout: 120_000 }
+    )
+    const raw = JSON.parse(stdout.trim() || '[]')
+    const arr = Array.isArray(raw) ? raw : [raw]
+    return arr.map((t: Record<string, unknown>) => ({
+      name: String(t.TaskName ?? ''),
+      state: String(t.State ?? ''),
+    }))
+  } catch {
+    return []
+  }
+}
+
+export async function openPathInExplorer(p: string): Promise<void> {
+  const resolved = resolveSafePath(p)
+  await execFileAsync('explorer.exe', [resolved], { windowsHide: true })
+}
+
+export function killProcess(pid: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('taskkill', ['/PID', String(pid), '/F'], { windowsHide: true })
+    proc.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`taskkill exit ${code}`))))
+    proc.on('error', reject)
+  })
+}
+
+export async function getWindowsFeaturesSnippet(): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync(
+      'dism.exe',
+      ['/Online', '/Get-Features', '/Format:Table'],
+      { windowsHide: true, maxBuffer: 5 * 1024 * 1024, timeout: 60_000 }
+    )
+    return stdout.slice(0, 120_000)
+  } catch (e) {
+    return String((e as Error).message)
+  }
+}

electron/main.ts

@@ -0,0 +1,131 @@
+import { app, BrowserWindow, clipboard, dialog, ipcMain, shell } from 'electron'
+import * as path from 'node:path'
+import * as fssync from 'node:fs'
+import {
+  getDrivesWin,
+  listDirectory,
+  computeFolderSize,
+  findLargeFiles,
+  getProcessesWin,
+  getServicesWin,
+  getInstalledPrograms,
+  getSystemSnapshot,
+  getNetworkInterfaces,
+  getEnvSnapshot,
+  getStartupFolders,
+  getTempAudit,
+  getScheduledTasksSummary,
+  openPathInExplorer,
+  killProcess,
+  getWindowsFeaturesSnippet,
+} from './audit'
+import { startPythonBackend, stopPythonBackend } from './pythonBackend'
+
+const isDev = !!process.env.VITE_DEV_SERVER_URL
+
+function notesPath() {
+  return path.join(app.getPath('userData'), 'auditor-notes.json')
+}
+
+function loadNotes(): Record<string, string> {
+  try {
+    const raw = fssync.readFileSync(notesPath(), 'utf8')
+    return JSON.parse(raw) as Record<string, string>
+  } catch {
+    return {}
+  }
+}
+
+function saveNotes(n: Record<string, string>) {
+  fssync.mkdirSync(path.dirname(notesPath()), { recursive: true })
+  fssync.writeFileSync(notesPath(), JSON.stringify(n, null, 2), 'utf8')
+}
+
+function createWindow() {
+  const win = new BrowserWindow({
+    width: 1280,
+    height: 800,
+    minWidth: 960,
+    minHeight: 640,
+    backgroundColor: '#0d0f12',
+    titleBarStyle: process.platform === 'darwin' ? 'hiddenInset' : 'default',
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false,
+    },
+  })
+
+  if (isDev) {
+    win.loadURL(process.env.VITE_DEV_SERVER_URL!)
+  } else {
+    win.loadFile(path.join(__dirname, '../dist/index.html'))
+  }
+}
+
+app.whenReady().then(async () => {
+  try {
+    await startPythonBackend()
+  } catch (e) {
+    dialog.showErrorBox(
+      'Python backend required',
+      `${String(e)}\n\nInstall: cd backend && pip install -r requirements.txt`
+    )
+    app.quit()
+    return
+  }
+
+  ipcMain.handle('audit:drives', () => getDrivesWin())
+  ipcMain.handle('audit:listDir', (_e, dirPath: string, opts?: { maxEntries?: number }) =>
+    listDirectory(dirPath, opts ?? {})
+  )
+  ipcMain.handle('audit:folderSize', (_e, dirPath: string) => computeFolderSize(dirPath))
+  ipcMain.handle('audit:largeFiles', (_e, rootPath: string, minBytes: number, maxResults: number) =>
+    findLargeFiles(rootPath, minBytes, maxResults)
+  )
+  ipcMain.handle('audit:processes', () => getProcessesWin())
+  ipcMain.handle('audit:services', () => getServicesWin())
+  ipcMain.handle('audit:installed', () => getInstalledPrograms())
+  ipcMain.handle('audit:system', () => getSystemSnapshot())
+  ipcMain.handle('audit:network', () => getNetworkInterfaces())
+  ipcMain.handle('audit:env', (_e, keys?: string[]) => getEnvSnapshot(keys))
+  ipcMain.handle('audit:startup', () => getStartupFolders())
+  ipcMain.handle('audit:temp', () => getTempAudit())
+  ipcMain.handle('audit:tasks', () => getScheduledTasksSummary())
+  ipcMain.handle('audit:features', () => getWindowsFeaturesSnippet())
+  ipcMain.handle('audit:openExplorer', (_e, p: string) => openPathInExplorer(p))
+  ipcMain.handle('audit:killProcess', (_e, pid: number) => killProcess(pid))
+  ipcMain.handle('audit:openExternal', (_e, url: string) => shell.openExternal(url))
+  ipcMain.handle('clipboard:writeText', (_e, text: string) => {
+    clipboard.writeText(text)
+  })
+
+  ipcMain.handle('notes:getAll', () => loadNotes())
+  ipcMain.handle('notes:set', (_e, key: string, value: string) => {
+    const all = loadNotes()
+    if (value.trim() === '') delete all[key]
+    else all[key] = value
+    saveNotes(all)
+    return all
+  })
+  ipcMain.handle('notes:delete', (_e, key: string) => {
+    const all = loadNotes()
+    delete all[key]
+    saveNotes(all)
+    return all
+  })
+
+  createWindow()
+  app.on('activate', () => {
+    if (BrowserWindow.getAllWindows().length === 0) createWindow()
+  })
+})
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') app.quit()
+})
+
+app.on('before-quit', () => {
+  stopPythonBackend()
+})

electron/preload.ts

@@ -0,0 +1,52 @@
+import { contextBridge, ipcRenderer } from 'electron'
+
+export interface AuditorAPI {
+  drives: () => Promise<unknown>
+  listDir: (dirPath: string, opts?: { maxEntries?: number }) => Promise<unknown>
+  folderSize: (dirPath: string) => Promise<unknown>
+  largeFiles: (rootPath: string, minBytes: number, maxResults: number) => Promise<unknown>
+  processes: () => Promise<unknown>
+  services: () => Promise<unknown>
+  installed: () => Promise<unknown>
+  system: () => Promise<unknown>
+  network: () => Promise<unknown>
+  env: (keys?: string[]) => Promise<unknown>
+  startup: () => Promise<unknown>
+  temp: () => Promise<unknown>
+  tasks: () => Promise<unknown>
+  features: () => Promise<string>
+  openExplorer: (p: string) => Promise<void>
+  killProcess: (pid: number) => Promise<void>
+  openExternal: (url: string) => Promise<void>
+  clipboardWriteText: (text: string) => Promise<void>
+  notesGetAll: () => Promise<Record<string, string>>
+  notesSet: (key: string, value: string) => Promise<Record<string, string>>
+  notesDelete: (key: string) => Promise<Record<string, string>>
+}
+
+const api: AuditorAPI = {
+  drives: () => ipcRenderer.invoke('audit:drives'),
+  listDir: (dirPath, opts) => ipcRenderer.invoke('audit:listDir', dirPath, opts),
+  folderSize: (dirPath) => ipcRenderer.invoke('audit:folderSize', dirPath),
+  largeFiles: (rootPath, minBytes, maxResults) =>
+    ipcRenderer.invoke('audit:largeFiles', rootPath, minBytes, maxResults),
+  processes: () => ipcRenderer.invoke('audit:processes'),
+  services: () => ipcRenderer.invoke('audit:services'),
+  installed: () => ipcRenderer.invoke('audit:installed'),
+  system: () => ipcRenderer.invoke('audit:system'),
+  network: () => ipcRenderer.invoke('audit:network'),
+  env: (keys) => ipcRenderer.invoke('audit:env', keys),
+  startup: () => ipcRenderer.invoke('audit:startup'),
+  temp: () => ipcRenderer.invoke('audit:temp'),
+  tasks: () => ipcRenderer.invoke('audit:tasks'),
+  features: () => ipcRenderer.invoke('audit:features'),
+  openExplorer: (p) => ipcRenderer.invoke('audit:openExplorer', p),
+  killProcess: (pid) => ipcRenderer.invoke('audit:killProcess', pid),
+  openExternal: (url) => ipcRenderer.invoke('audit:openExternal', url),
+  clipboardWriteText: (text) => ipcRenderer.invoke('clipboard:writeText', text),
+  notesGetAll: () => ipcRenderer.invoke('notes:getAll'),
+  notesSet: (key, value) => ipcRenderer.invoke('notes:set', key, value),
+  notesDelete: (key) => ipcRenderer.invoke('notes:delete', key),
+}
+
+contextBridge.exposeInMainWorld('auditor', api)

electron/pythonBackend.ts

@@ -0,0 +1,135 @@
+/**
+ * Spawns the FastAPI Python backend and exposes HTTP helpers for the main process.
+ * Python handles hot paths (filesystem sizes, processes, drives, system, network, env).
+ */
+import { spawn, type ChildProcess } from 'node:child_process'
+import * as net from 'node:net'
+import * as path from 'node:path'
+
+let child: ChildProcess | null = null
+let baseUrl = ''
+
+export function getPythonBaseUrl(): string {
+  return baseUrl
+}
+
+function getFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const s = net.createServer()
+    s.listen(0, '127.0.0.1', () => {
+      const a = s.address()
+      const p = typeof a === 'object' && a ? a.port : 0
+      s.close(() => resolve(p))
+    })
+    s.on('error', reject)
+  })
+}
+
+async function waitForHealth(port: number, timeoutMs: number): Promise<void> {
+  const url = `http://127.0.0.1:${port}/health`
+  const t0 = Date.now()
+  while (Date.now() - t0 < timeoutMs) {
+    try {
+      const r = await fetch(url)
+      if (r.ok) return
+    } catch {
+      /* retry */
+    }
+    await new Promise((r) => setTimeout(r, 120))
+  }
+  throw new Error(`Python backend did not respond at ${url}`)
+}
+
+export async function startPythonBackend(): Promise<void> {
+  const port = await getFreePort()
+  const backendDir = path.join(__dirname, '..', 'backend')
+  const py =
+    process.env.PYTHON_PATH ?? (process.platform === 'win32' ? 'python' : 'python3')
+
+  child = spawn(
+    py,
+    ['-m', 'uvicorn', 'main:app', '--host', '127.0.0.1', '--port', String(port), '--log-level', 'warning'],
+    {
+      cwd: backendDir,
+      env: { ...process.env, AUDITOR_PY_PORT: String(port) },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    }
+  )
+
+  let stderrBuf = ''
+  child.stderr?.on('data', (d: Buffer) => {
+    stderrBuf += d.toString()
+    if (stderrBuf.length > 8000) stderrBuf = stderrBuf.slice(-4000)
+  })
+
+  await new Promise<void>((resolve, reject) => {
+    const fail = (err: Error) => {
+      try {
+        child?.kill()
+      } catch {
+        /* ignore */
+      }
+      reject(err)
+    }
+
+    const t = setTimeout(() => {
+      fail(
+        new Error(
+          `Python backend startup timed out. Install: cd backend && pip install -r requirements.txt\n${stderrBuf}`
+        )
+      )
+    }, 25_000)
+
+    child!.once('error', (err) => {
+      clearTimeout(t)
+      fail(err instanceof Error ? err : new Error(String(err)))
+    })
+
+    waitForHealth(port, 24_000)
+      .then(() => {
+        clearTimeout(t)
+        resolve()
+      })
+      .catch((e) => {
+        clearTimeout(t)
+        fail(e instanceof Error ? e : new Error(String(e)))
+      })
+  })
+
+  baseUrl = `http://127.0.0.1:${port}`
+}
+
+export function stopPythonBackend(): void {
+  if (child) {
+    try {
+      child.kill()
+    } catch {
+      /* ignore */
+    }
+    child = null
+  }
+  baseUrl = ''
+}
+
+export async function pyGet<T>(pathname: string): Promise<T> {
+  const r = await fetch(`${baseUrl}${pathname}`)
+  if (!r.ok) {
+    const t = await r.text()
+    throw new Error(t || r.statusText)
+  }
+  return r.json() as Promise<T>
+}
+
+export async function pyPost<T>(pathname: string, body: unknown): Promise<T> {
+  const r = await fetch(`${baseUrl}${pathname}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  if (!r.ok) {
+    const t = await r.text()
+    throw new Error(t || r.statusText)
+  }
+  return r.json() as Promise<T>
+}

electron/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "lib": ["ES2022"],
+    "outDir": "../dist-electron",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "declaration": false,
+    "noEmitOnError": true
+  },
+  "include": ["./**/*.ts"]
+}

index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Computer Auditor</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package.json

@@ -0,0 +1,31 @@
+{
+  "name": "computer-auditor",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Computer system audit dashboard",
+  "main": "dist-electron/main.js",
+  "scripts": {
+    "dev": "npm run build:electron && concurrently -k \"npm run dev:vite\" \"npm run dev:electron\"",
+    "dev:vite": "vite",
+    "dev:electron": "wait-on tcp:5173 && cross-env VITE_DEV_SERVER_URL=http://localhost:5173 electron .",
+    "build:electron": "node node_modules/typescript/lib/tsc.js -p electron/tsconfig.json",
+    "build": "node node_modules/typescript/lib/tsc.js -p electron/tsconfig.json && vite build",
+    "start": "electron .",
+    "preview:app": "cross-env NODE_ENV=production electron ."
+  },
+  "dependencies": {
+    "@types/node": "^22.10.1",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "concurrently": "^9.1.0",
+    "cross-env": "^7.0.3",
+    "electron": "^33.2.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-icons": "^5.4.0",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.11",
+    "wait-on": "^8.0.1"
+  }
+}

src/App.tsx

@@ -0,0 +1,1073 @@
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from 'react'
+import {
+  MdApps,
+  MdDns,
+  MdFolderOpen,
+  MdMemory,
+  MdRefresh,
+  MdSchedule,
+  MdSettingsApplications,
+  MdStorage,
+  MdViewModule,
+  MdWarning,
+  MdOpenInNew,
+  MdArrowUpward,
+  MdSearch,
+  MdNoteAdd,
+  MdDeleteForever,
+  MdSave,
+  MdStopCircle,
+  MdComputer,
+  MdCode,
+  MdContentCopy,
+  MdDataUsage,
+} from 'react-icons/md'
+import { IconButton } from './components/IconButton'
+import { formatBytes, formatSizeKb, formatUptime } from './utils/format'
+import type {
+  DirEntry,
+  DriveInfo,
+  InstalledApp,
+  NavId,
+  NetworkRow,
+  ProcessRow,
+  ServiceRow,
+  SystemSnapshot,
+} from './types'
+
+const api = typeof window !== 'undefined' ? window.auditor : undefined
+
+function useNotes() {
+  const [map, setMap] = useState<Record<string, string>>({})
+  const refresh = useCallback(async () => {
+    if (!api) return
+    setMap(await api.notesGetAll())
+  }, [])
+  useEffect(() => {
+    void refresh()
+  }, [refresh])
+  const setNote = useCallback(
+    async (key: string, value: string) => {
+      if (!api) return
+      setMap(await api.notesSet(key, value))
+    },
+    []
+  )
+  const del = useCallback(
+    async (key: string) => {
+      if (!api) return
+      setMap(await api.notesDelete(key))
+    },
+    []
+  )
+  return { map, refresh, setNote, del }
+}
+
+const NAV: { id: NavId; label: string; icon: ReactNode }[] = [
+  { id: 'overview', label: 'Overview', icon: <MdViewModule /> },
+  { id: 'storage', label: 'Storage & volumes', icon: <MdStorage /> },
+  { id: 'filesystem', label: 'Folders & files', icon: <MdFolderOpen /> },
+  { id: 'processes', label: 'Processes', icon: <MdMemory /> },
+  { id: 'services', label: 'Services', icon: <MdSettingsApplications /> },
+  { id: 'apps', label: 'Installed software', icon: <MdApps /> },
+  { id: 'network', label: 'Network', icon: <MdDns /> },
+  { id: 'environment', label: 'Environment', icon: <MdCode /> },
+  { id: 'startup', label: 'Startup items', icon: <MdComputer /> },
+  { id: 'scheduled', label: 'Scheduled tasks', icon: <MdSchedule /> },
+  { id: 'features', label: 'Windows features', icon: <MdWarning /> },
+]
+
+export default function App() {
+  const [nav, setNav] = useState<NavId>('overview')
+  const [status, setStatus] = useState('')
+  const [err, setErr] = useState('')
+  const notes = useNotes()
+
+  const [sys, setSys] = useState<SystemSnapshot | null>(null)
+  const [drives, setDrives] = useState<DriveInfo[]>([])
+  const [path, setPath] = useState('')
+  const [entries, setEntries] = useState<DirEntry[]>([])
+  const [proc, setProc] = useState<ProcessRow[]>([])
+  const [svc, setSvc] = useState<ServiceRow[]>([])
+  const [apps, setApps] = useState<InstalledApp[]>([])
+  const [net, setNet] = useState<NetworkRow[]>([])
+  const [envText, setEnvText] = useState('')
+  const [startupBlocks, setStartupBlocks] = useState<{ path: string; entries: DirEntry[] }[]>([])
+  const [tasks, setTasks] = useState<{ name: string; state: string }[]>([])
+  const [feat, setFeat] = useState('')
+  const [tempAudit, setTempAudit] = useState<{ path: string; bytes: number; files: number; truncated: boolean }[]>(
+    []
+  )
+
+  const [selectedKey, setSelectedKey] = useState<string | null>(null)
+  const [noteDraft, setNoteDraft] = useState('')
+
+  const [largeRoot, setLargeRoot] = useState('')
+  const [largeMinMb, setLargeMinMb] = useState(100)
+  const [largeHits, setLargeHits] = useState<{ path: string; sizeBytes: number }[]>([])
+  const [folderTotal, setFolderTotal] = useState<{
+    bytes: number
+    files: number
+    truncated: boolean
+  } | null>(null)
+
+  const [procFilter, setProcFilter] = useState('')
+  const [svcFilter, setSvcFilter] = useState('')
+  const [appFilter, setAppFilter] = useState('')
+
+  const clearMsg = () => {
+    setErr('')
+    setStatus('')
+  }
+
+  const loadSystem = useCallback(async (opts?: { silent?: boolean }) => {
+    if (!api) return
+    if (!opts?.silent) clearMsg()
+    try {
+      setSys((await api.system()) as SystemSnapshot)
+      if (!opts?.silent) setStatus('System snapshot updated')
+    } catch (e) {
+      if (!opts?.silent) setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadDrives = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    try {
+      setDrives((await api.drives()) as DriveInfo[])
+      setStatus('Volumes refreshed')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadDir = useCallback(async () => {
+    if (!api || !path.trim()) return
+    clearMsg()
+    try {
+      setStatus('Listing folder (measuring sizes)…')
+      setEntries((await api.listDir(path.trim(), { maxEntries: 800 })) as DirEntry[])
+      setStatus('Directory listed')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [path])
+
+  const loadProcesses = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    setStatus('Loading processes…')
+    try {
+      const rows = (await api.processes()) as ProcessRow[]
+      setProc(rows)
+      setStatus(`Processes loaded (${rows.length})`)
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadServices = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    setStatus('Loading services…')
+    try {
+      setSvc((await api.services()) as ServiceRow[])
+      setStatus('Services loaded')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadApps = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    try {
+      setApps((await api.installed()) as InstalledApp[])
+      setStatus('Installed programs enumerated')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadNetwork = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    try {
+      setNet((await api.network()) as NetworkRow[])
+      setStatus('Network interfaces read')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadEnv = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    try {
+      const o = (await api.env()) as Record<string, string>
+      const lines = Object.keys(o)
+        .sort()
+        .map((k) => `${k}=${o[k]}`)
+      setEnvText(lines.join('\n'))
+      setStatus('Environment loaded')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadStartup = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    try {
+      setStartupBlocks((await api.startup()) as { path: string; entries: DirEntry[] }[])
+      setStatus('Startup folders scanned')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadTasks = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    setStatus('Loading scheduled tasks…')
+    try {
+      setTasks((await api.tasks()) as { name: string; state: string }[])
+      setStatus('Scheduled tasks loaded')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadFeatures = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    setStatus('Querying optional features (may take a minute)…')
+    try {
+      setFeat(await api.features())
+      setStatus('Feature list retrieved')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  const loadTemp = useCallback(async () => {
+    if (!api) return
+    clearMsg()
+    setStatus('Measuring temp folders…')
+    try {
+      setTempAudit(
+        (await api.temp()) as { path: string; bytes: number; files: number; truncated: boolean }[]
+      )
+      setStatus('Temp audit complete')
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }, [])
+
+  useEffect(() => {
+    if (!api) return
+    void loadSystem()
+    const t = setInterval(() => void loadSystem({ silent: true }), 60_000)
+    return () => clearInterval(t)
+  }, [loadSystem])
+
+  const [pathSeeded, setPathSeeded] = useState(false)
+  useEffect(() => {
+    if (!api || pathSeeded) return
+    if (sys?.homedir) {
+      setPath(sys.homedir)
+      setPathSeeded(true)
+    }
+  }, [api, sys, pathSeeded])
+
+  useEffect(() => {
+    if (selectedKey && notes.map[selectedKey] !== undefined) setNoteDraft(notes.map[selectedKey] ?? '')
+    else if (selectedKey) setNoteDraft('')
+  }, [selectedKey, notes.map])
+
+  const selectForNote = (key: string) => {
+    setSelectedKey(key)
+    setNoteDraft(notes.map[key] ?? '')
+  }
+
+  const saveNote = async () => {
+    if (!selectedKey) return
+    await notes.setNote(selectedKey, noteDraft)
+    setStatus('Note saved')
+  }
+
+  const copyText = async (text: string) => {
+    if (!api) return
+    try {
+      if (navigator.clipboard?.writeText) {
+        await navigator.clipboard.writeText(text)
+      } else {
+        await api.clipboardWriteText(text)
+      }
+      setStatus('Copied to clipboard')
+    } catch {
+      try {
+        await api.clipboardWriteText(text)
+        setStatus('Copied to clipboard')
+      } catch (e) {
+        setErr(String((e as Error).message))
+      }
+    }
+  }
+
+  const computeFolderTotal = async () => {
+    if (!api || !path.trim()) return
+    clearMsg()
+    setStatus('Computing folder size (capped walk)…')
+    try {
+      const r = (await api.folderSize(path.trim())) as { bytes: number; files: number; truncated: boolean }
+      setFolderTotal(r)
+      setStatus(
+        `Folder total ${formatSizeKb(r.bytes, { truncated: r.truncated })} — ${r.files} files counted${r.truncated ? ' (hit file cap)' : ''}`
+      )
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }
+
+  const runLargeScan = async () => {
+    if (!api) return
+    const root = largeRoot.trim() || path.trim()
+    if (!root) return
+    clearMsg()
+    setStatus('Scanning for large files…')
+    try {
+      const hits = (await api.largeFiles(root, largeMinMb * 1024 * 1024, 80)) as {
+        path: string
+        sizeBytes: number
+      }[]
+      setLargeHits(hits)
+      setStatus(`Found ${hits.length} files`)
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }
+
+  const killPid = async (pid: number) => {
+    if (!api) return
+    if (!window.confirm(`End process ${pid}? Unsaved data in that process may be lost.`)) return
+    try {
+      await api.killProcess(pid)
+      setStatus(`Sent terminate to PID ${pid}`)
+      void loadProcesses()
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }
+
+  const openExplorer = async (p: string) => {
+    if (!api) return
+    try {
+      await api.openExplorer(p)
+    } catch (e) {
+      setErr(String((e as Error).message))
+    }
+  }
+
+  const filteredProc = useMemo(() => {
+    const q = procFilter.trim().toLowerCase()
+    if (!q) return proc
+    return proc.filter(
+      (p) =>
+        p.name.toLowerCase().includes(q) ||
+        String(p.pid).includes(q) ||
+        (p.commandLine ?? '').toLowerCase().includes(q)
+    )
+  }, [proc, procFilter])
+
+  const filteredSvc = useMemo(() => {
+    const q = svcFilter.trim().toLowerCase()
+    if (!q) return svc
+    return svc.filter(
+      (s) =>
+        s.name.toLowerCase().includes(q) ||
+        s.displayName.toLowerCase().includes(q) ||
+        s.state.toLowerCase().includes(q)
+    )
+  }, [svc, svcFilter])
+
+  const filteredApps = useMemo(() => {
+    const q = appFilter.trim().toLowerCase()
+    if (!q) return apps
+    return apps.filter(
+      (a) =>
+        a.name.toLowerCase().includes(q) ||
+        a.publisher.toLowerCase().includes(q) ||
+        a.installLocation.toLowerCase().includes(q)
+    )
+  }, [apps, appFilter])
+
+  if (!api) {
+    return (
+      <div className="content-scroll">
+        <p className="status-msg error">
+          This UI must be run inside the Electron shell so it can reach your system. Use{' '}
+          <span className="mono">npm run dev</span>.
+        </p>
+      </div>
+    )
+  }
+
+  const memUsed = sys ? sys.totalMem - sys.freeMem : 0
+  const memPct = sys && sys.totalMem ? Math.round((memUsed / sys.totalMem) * 100) : 0
+
+  return (
+    <div className="app-shell">
+      <aside className="sidebar">
+        <div className="sidebar-brand">
+          <h1>Computer Auditor</h1>
+          <p>System inspection dashboard</p>
+        </div>
+        {NAV.map((item) => (
+          <button
+            key={item.id}
+            type="button"
+            className={`nav-item ${nav === item.id ? 'active' : ''}`}
+            onClick={() => setNav(item.id)}
+          >
+            {item.icon}
+            {item.label}
+          </button>
+        ))}
+      </aside>
+
+      <div className="main">
+        <div className="toolbar">
+          <h2 className="panel-title">{NAV.find((n) => n.id === nav)?.label}</h2>
+          <span className="toolbar-spacer" />
+          <IconButton label="Refresh system snapshot" onClick={() => void loadSystem()}>
+            <MdRefresh />
+          </IconButton>
+          {status && <span className="status-msg">{status}</span>}
+          {err && <span className="status-msg error">{err}</span>}
+        </div>
+
+        <div className="content-scroll">
+          {nav === 'overview' && (
+            <>
+              <div className="card-grid">
+                <div className="card">
+                  <div className="card-label">Host</div>
+                  <div className="card-value">{sys?.hostname ?? '—'}</div>
+                  <div className="card-sub mono">{sys?.userInfo}</div>
+                </div>
+                <div className="card">
+                  <div className="card-label">Platform</div>
+                  <div className="card-value">{sys?.platform ?? '—'}</div>
+                  <div className="card-sub mono">
+                    {sys?.release} / {sys?.arch}
+                  </div>
+                </div>
+                <div className="card">
+                  <div className="card-label">Uptime</div>
+                  <div className="card-value">{sys ? formatUptime(sys.uptimeSec) : '—'}</div>
+                </div>
+                <div className="card">
+                  <div className="card-label">Memory</div>
+                  <div className="card-value">
+                    {sys ? `${memPct}% used` : '—'}
+                  </div>
+                  <div className="card-sub">
+                    {sys ? `${formatBytes(memUsed)} / ${formatBytes(sys.totalMem)}` : ''}
+                  </div>
+                  {sys && (
+                    <div className="bar-track">
+                      <div className="bar-fill" style={{ width: `${memPct}%` }} />
+                    </div>
+                  )}
+                </div>
+                <div className="card">
+                  <div className="card-label">CPU</div>
+                  <div className="card-value">{sys?.cpuCount ?? '—'} logical</div>
+                  <div className="card-sub">{sys?.cpuModel}</div>
+                </div>
+                <div className="card">
+                  <div className="card-label">Home & temp</div>
+                  <div className="card-sub mono">{sys?.homedir}</div>
+                  <div className="card-sub mono">{sys?.tmpdir}</div>
+                </div>
+              </div>
+
+              <div style={{ marginTop: 20 }}>
+                <div className="input-row">
+                  <IconButton label="Load logical volumes" onClick={() => void loadDrives()}>
+                    <MdStorage />
+                  </IconButton>
+                  <IconButton label="Measure temp directories" onClick={() => void loadTemp()}>
+                    <MdFolderOpen />
+                  </IconButton>
+                </div>
+                {drives.length > 0 && (
+                  <table className="data-table">
+                    <thead>
+                      <tr>
+                        <th>Volume</th>
+                        <th>Label</th>
+                        <th>Used</th>
+                        <th>Free</th>
+                        <th>Total</th>
+                        <th />
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {drives.map((d) => {
+                        const pct = d.totalBytes ? Math.round((d.usedBytes / d.totalBytes) * 100) : 0
+                        return (
+                          <tr key={d.letter}>
+                            <td className="mono">{d.letter}</td>
+                            <td>{d.label || '—'}</td>
+                            <td>
+                              {formatBytes(d.usedBytes)} ({pct}%)
+                            </td>
+                            <td>{formatBytes(d.freeBytes)}</td>
+                            <td>{formatBytes(d.totalBytes)}</td>
+                            <td>
+                              <IconButton
+                                label="Open in Explorer"
+                                onClick={() => void openExplorer(d.mount + '\\')}
+                              >
+                                <MdOpenInNew />
+                              </IconButton>
+                              <IconButton
+                                label="Attach note to this volume"
+                                onClick={() => selectForNote(`drive:${d.letter}`)}
+                              >
+                                <MdNoteAdd />
+                              </IconButton>
+                            </td>
+                          </tr>
+                        )
+                      })}
+                    </tbody>
+                  </table>
+                )}
+                {tempAudit.length > 0 && (
+                  <table className="data-table" style={{ marginTop: 16 }}>
+                    <thead>
+                      <tr>
+                        <th>Temp path</th>
+                        <th>Size</th>
+                        <th>Files (sampled)</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {tempAudit.map((t) => (
+                        <tr key={t.path}>
+                          <td className="mono">{t.path}</td>
+                          <td>{formatBytes(t.bytes)}</td>
+                          <td>
+                            {t.files}
+                            {t.truncated ? ' (cap reached)' : ''}
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                )}
+              </div>
+            </>
+          )}
+
+          {nav === 'storage' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Refresh drive list" onClick={() => void loadDrives()}>
+                  <MdRefresh />
+                </IconButton>
+              </div>
+              <table className="data-table">
+                <thead>
+                  <tr>
+                    <th>Volume</th>
+                    <th>Label</th>
+                    <th>Used</th>
+                    <th>Free</th>
+                    <th>Total</th>
+                    <th />
+                  </tr>
+                </thead>
+                <tbody>
+                  {drives.map((d) => {
+                    const pct = d.totalBytes ? Math.round((d.usedBytes / d.totalBytes) * 100) : 0
+                    return (
+                      <tr key={d.letter}>
+                        <td className="mono">{d.letter}</td>
+                        <td>{d.label || '—'}</td>
+                        <td>
+                          {formatBytes(d.usedBytes)} ({pct}%)
+                          <div className="bar-track">
+                            <div className="bar-fill" style={{ width: `${pct}%` }} />
+                          </div>
+                        </td>
+                        <td>{formatBytes(d.freeBytes)}</td>
+                        <td>{formatBytes(d.totalBytes)}</td>
+                        <td>
+                          <IconButton label="Open volume" onClick={() => void openExplorer(d.mount + '\\')}>
+                            <MdOpenInNew />
+                          </IconButton>
+                          <IconButton label="Note" onClick={() => selectForNote(`drive:${d.letter}`)}>
+                            <MdNoteAdd />
+                          </IconButton>
+                        </td>
+                      </tr>
+                    )
+                  })}
+                </tbody>
+              </table>
+            </>
+          )}
+
+          {nav === 'filesystem' && (
+            <>
+              <div className="input-row">
+                <input
+                  type="text"
+                  value={path}
+                  onChange={(e) => setPath(e.target.value)}
+                  placeholder="Folder path"
+                  className="mono"
+                  style={{ flex: 1, minWidth: 280 }}
+                />
+                <IconButton label="List directory" onClick={() => void loadDir()}>
+                  <MdRefresh />
+                </IconButton>
+                <IconButton label="Parent folder" onClick={() => setPath((p) => p.replace(/[/\\][^/\\]*$/, ''))}>
+                  <MdArrowUpward />
+                </IconButton>
+                <IconButton label="Open in Explorer" onClick={() => void openExplorer(path)}>
+                  <MdOpenInNew />
+                </IconButton>
+                <IconButton label="Note on this path" onClick={() => selectForNote(`path:${path}`)}>
+                  <MdNoteAdd />
+                </IconButton>
+                <IconButton label="Copy current path" onClick={() => void copyText(path)}>
+                  <MdContentCopy />
+                </IconButton>
+                <IconButton label="Compute folder size (recursive, capped)" onClick={() => void computeFolderTotal()}>
+                  <MdDataUsage />
+                </IconButton>
+              </div>
+              {folderTotal && (
+                <p className="status-msg" style={{ marginTop: 0 }}>
+                  Aggregated: {formatSizeKb(folderTotal.bytes, { truncated: folderTotal.truncated })} —{' '}
+                  {folderTotal.files} files
+                  {folderTotal.truncated ? ' (enumeration capped for safety)' : ''}
+                </p>
+              )}
+              <div className="input-row">
+                <input
+                  type="text"
+                  value={largeRoot}
+                  onChange={(e) => setLargeRoot(e.target.value)}
+                  placeholder="Large-file scan root (defaults to path above)"
+                  className="mono"
+                  style={{ flex: 1, minWidth: 240 }}
+                />
+                <input
+                  type="number"
+                  value={largeMinMb}
+                  min={1}
+                  onChange={(e) => setLargeMinMb(Number(e.target.value) || 100)}
+                  title="Minimum size MB"
+                />
+                <IconButton label="Find large files" onClick={() => void runLargeScan()}>
+                  <MdSearch />
+                </IconButton>
+              </div>
+              <table className="data-table">
+                <thead>
+                  <tr>
+                    <th>Name</th>
+                    <th>Type</th>
+                    <th>Size (KB)</th>
+                    <th />
+                  </tr>
+                </thead>
+                <tbody>
+                  {entries.map((e) => (
+                    <tr
+                      key={e.fullPath}
+                      className={selectedKey === `path:${e.fullPath}` ? 'selected' : ''}
+                      onDoubleClick={() => e.isDirectory && setPath(e.fullPath)}
+                    >
+                      <td className="mono">{e.name}</td>
+                      <td>{e.isDirectory ? 'Folder' : 'File'}</td>
+                      <td>
+                        {e.error
+                          ? e.error
+                          : formatSizeKb(e.sizeBytes, { truncated: e.sizeTruncated })}
+                      </td>
+                      <td>
+                        {e.isDirectory && (
+                          <IconButton label="Enter folder" onClick={() => setPath(e.fullPath)}>
+                            <MdFolderOpen />
+                          </IconButton>
+                        )}
+                        <IconButton label="Explorer" onClick={() => void openExplorer(e.fullPath)}>
+                          <MdOpenInNew />
+                        </IconButton>
+                        <IconButton label="Note" onClick={() => selectForNote(`path:${e.fullPath}`)}>
+                          <MdNoteAdd />
+                        </IconButton>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+              {largeHits.length > 0 && (
+                <>
+                  <h3 style={{ marginTop: 24, fontSize: 13 }}>Large files</h3>
+                  <table className="data-table">
+                    <thead>
+                      <tr>
+                        <th>Path</th>
+                        <th>Size (KB)</th>
+                        <th />
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {largeHits.map((h) => (
+                        <tr key={h.path}>
+                          <td className="mono">{h.path}</td>
+                          <td>{formatSizeKb(h.sizeBytes)}</td>
+                          <td>
+                            <IconButton label="Open location" onClick={() => void openExplorer(h.path)}>
+                              <MdOpenInNew />
+                            </IconButton>
+                            <IconButton label="Note" onClick={() => selectForNote(`path:${h.path}`)}>
+                              <MdNoteAdd />
+                            </IconButton>
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </>
+              )}
+            </>
+          )}
+
+          {nav === 'processes' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Reload process list" onClick={() => void loadProcesses()}>
+                  <MdRefresh />
+                </IconButton>
+                <input
+                  type="search"
+                  placeholder="Filter name, PID, command line"
+                  value={procFilter}
+                  onChange={(e) => setProcFilter(e.target.value)}
+                  style={{ minWidth: 240, flex: 1 }}
+                />
+              </div>
+              <table className="data-table">
+                <thead>
+                  <tr>
+                    <th>PID</th>
+                    <th>Name</th>
+                    <th>Memory</th>
+                    <th>CPU (session est.)</th>
+                    <th />
+                  </tr>
+                </thead>
+                <tbody>
+                  {filteredProc.map((p) => (
+                    <tr
+                      key={p.pid}
+                      className={selectedKey === `proc:${p.pid}` ? 'selected' : ''}
+                      title={p.commandLine}
+                    >
+                      <td className="mono">{p.pid}</td>
+                      <td>{p.name}</td>
+                      <td>{formatBytes(p.memoryBytes)}</td>
+                      <td>{p.cpuSeconds != null ? `${p.cpuSeconds}s` : '—'}</td>
+                      <td>
+                        <IconButton label="Add note for process" onClick={() => selectForNote(`proc:${p.pid}`)}>
+                          <MdNoteAdd />
+                        </IconButton>
+                        <IconButton label="End process" onClick={() => void killPid(p.pid)}>
+                          <MdStopCircle />
+                        </IconButton>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </>
+          )}
+
+          {nav === 'services' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Reload services" onClick={() => void loadServices()}>
+                  <MdRefresh />
+                </IconButton>
+                <input
+                  type="search"
+                  placeholder="Filter"
+                  value={svcFilter}
+                  onChange={(e) => setSvcFilter(e.target.value)}
+                  style={{ minWidth: 240, flex: 1 }}
+                />
+              </div>
+              <table className="data-table">
+                <thead>
+                  <tr>
+                    <th>Name</th>
+                    <th>Display name</th>
+                    <th>State</th>
+                    <th>Start</th>
+                    <th />
+                  </tr>
+                </thead>
+                <tbody>
+                  {filteredSvc.map((s) => (
+                    <tr key={s.name} className={selectedKey === `svc:${s.name}` ? 'selected' : ''}>
+                      <td className="mono">{s.name}</td>
+                      <td>{s.displayName}</td>
+                      <td>{s.state}</td>
+                      <td>{s.startType}</td>
+                      <td>
+                        <IconButton label="Note" onClick={() => selectForNote(`svc:${s.name}`)}>
+                          <MdNoteAdd />
+                        </IconButton>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </>
+          )}
+
+          {nav === 'apps' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Reload installed programs" onClick={() => void loadApps()}>
+                  <MdRefresh />
+                </IconButton>
+                <input
+                  type="search"
+                  placeholder="Filter"
+                  value={appFilter}
+                  onChange={(e) => setAppFilter(e.target.value)}
+                  style={{ minWidth: 240, flex: 1 }}
+                />
+              </div>
+              <table className="data-table">
+                <thead>
+                  <tr>
+                    <th>Name</th>
+                    <th>Version</th>
+                    <th>Publisher</th>
+                    <th>Location</th>
+                    <th>Est. size</th>
+                    <th />
+                  </tr>
+                </thead>
+                <tbody>
+                  {filteredApps.map((a) => (
+                    <tr
+                      key={a.name + a.version}
+                      className={selectedKey === `app:${a.name}` ? 'selected' : ''}
+                    >
+                      <td>{a.name}</td>
+                      <td className="mono">{a.version}</td>
+                      <td>{a.publisher}</td>
+                      <td className="mono">{a.installLocation || '—'}</td>
+                      <td>{a.estimatedSizeKb ? `${(a.estimatedSizeKb / 1024).toFixed(1)} MB` : '—'}</td>
+                      <td>
+                        {a.installLocation ? (
+                          <IconButton label="Open install folder" onClick={() => void openExplorer(a.installLocation)}>
+                            <MdOpenInNew />
+                          </IconButton>
+                        ) : null}
+                        <IconButton label="Note" onClick={() => selectForNote(`app:${a.name}`)}>
+                          <MdNoteAdd />
+                        </IconButton>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </>
+          )}
+
+          {nav === 'network' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Reload interfaces" onClick={() => void loadNetwork()}>
+                  <MdRefresh />
+                </IconButton>
+              </div>
+              <table className="data-table">
+                <thead>
+                  <tr>
+                    <th>Interface</th>
+                    <th>Address</th>
+                    <th>Family</th>
+                    <th>MAC</th>
+                    <th>Internal</th>
+                    <th />
+                  </tr>
+                </thead>
+                <tbody>
+                  {net.map((n, i) => (
+                    <tr key={`${n.name}-${n.address}-${i}`}>
+                      <td>{n.name}</td>
+                      <td className="mono">{n.address}</td>
+                      <td>{n.family}</td>
+                      <td className="mono">{n.mac ?? '—'}</td>
+                      <td>{n.internal ? 'yes' : 'no'}</td>
+                      <td>
+                        <IconButton label="Note" onClick={() => selectForNote(`net:${n.name}:${n.address}`)}>
+                          <MdNoteAdd />
+                        </IconButton>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </>
+          )}
+
+          {nav === 'environment' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Reload environment block" onClick={() => void loadEnv()}>
+                  <MdRefresh />
+                </IconButton>
+                <IconButton label="Note on whole environment view" onClick={() => selectForNote('env:all')}>
+                  <MdNoteAdd />
+                </IconButton>
+              </div>
+              <textarea className="mono" value={envText} readOnly spellCheck={false} style={{ minHeight: 400 }} />
+            </>
+          )}
+
+          {nav === 'startup' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Scan startup folders" onClick={() => void loadStartup()}>
+                  <MdRefresh />
+                </IconButton>
+              </div>
+              {startupBlocks.map((block) => (
+                <div key={block.path} style={{ marginBottom: 20 }}>
+                  <div className="card-label mono" style={{ marginBottom: 8 }}>
+                    {block.path}
+                  </div>
+                  <table className="data-table">
+                    <thead>
+                      <tr>
+                        <th>Item</th>
+                        <th>Type</th>
+                        <th />
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {block.entries.map((e) => (
+                        <tr key={e.fullPath}>
+                          <td className="mono">{e.name}</td>
+                          <td>{e.isDirectory ? 'Folder' : 'File'}</td>
+                          <td>
+                            <IconButton label="Open" onClick={() => void openExplorer(e.fullPath)}>
+                              <MdOpenInNew />
+                            </IconButton>
+                            <IconButton label="Note" onClick={() => selectForNote(`path:${e.fullPath}`)}>
+                              <MdNoteAdd />
+                            </IconButton>
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </div>
+              ))}
+            </>
+          )}
+
+          {nav === 'scheduled' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Reload tasks" onClick={() => void loadTasks()}>
+                  <MdRefresh />
+                </IconButton>
+              </div>
+              <table className="data-table">
+                <thead>
+                  <tr>
+                    <th>Task</th>
+                    <th>State</th>
+                    <th />
+                  </tr>
+                </thead>
+                <tbody>
+                  {tasks.map((t) => (
+                    <tr key={t.name} className={selectedKey === `task:${t.name}` ? 'selected' : ''}>
+                      <td className="mono">{t.name}</td>
+                      <td>{t.state}</td>
+                      <td>
+                        <IconButton label="Note" onClick={() => selectForNote(`task:${t.name}`)}>
+                          <MdNoteAdd />
+                        </IconButton>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </>
+          )}
+
+          {nav === 'features' && (
+            <>
+              <div className="input-row">
+                <IconButton label="Load DISM feature table" onClick={() => void loadFeatures()}>
+                  <MdRefresh />
+                </IconButton>
+                <IconButton label="Note on features output" onClick={() => selectForNote('features:snippet')}>
+                  <MdNoteAdd />
+                </IconButton>
+              </div>
+              <pre className="features-pre mono">{feat || 'Run refresh to pull optional features snapshot.'}</pre>
+            </>
+          )}
+        </div>
+
+        <footer className="notes-panel">
+          <header>
+            <strong>Notes</strong>
+            <span className="notes-key">{selectedKey ?? 'Select a row or volume to attach a note key.'}</span>
+          </header>
+          <textarea
+            placeholder="Audit notes for the selected item…"
+            value={noteDraft}
+            onChange={(e) => setNoteDraft(e.target.value)}
+            disabled={!selectedKey}
+          />
+          <div className="input-row" style={{ marginBottom: 0 }}>
+            <IconButton label="Save note" onClick={() => void saveNote()} disabled={!selectedKey}>
+              <MdSave />
+            </IconButton>
+            <IconButton
+              label="Clear note for key"
+              onClick={() => selectedKey && void notes.del(selectedKey)}
+              disabled={!selectedKey}
+            >
+              <MdDeleteForever />
+            </IconButton>
+            <IconButton label="Reload notes from disk" onClick={() => void notes.refresh()}>
+              <MdRefresh />
+            </IconButton>
+          </div>
+        </footer>
+      </div>
+    </div>
+  )
+}

src/components/IconButton.tsx

@@ -0,0 +1,29 @@
+import type { ReactNode } from 'react'
+
+type Props = {
+  label: string
+  onClick?: () => void
+  disabled?: boolean
+  children: ReactNode
+  className?: string
+}
+
+export function IconButton({ label, onClick, disabled, children, className = '' }: Props) {
+  return (
+    <span className={`icon-btn-wrap ${className}`.trim()}>
+      <button
+        type="button"
+        className="icon-btn"
+        aria-label={label}
+        title={label}
+        onClick={onClick}
+        disabled={disabled}
+      >
+        {children}
+      </button>
+      <span className="icon-btn-tooltip" role="tooltip">
+        {label}
+      </span>
+    </span>
+  )
+}

src/env.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="vite/client" />
+
+interface AuditorBridge {
+  drives: () => Promise<unknown>
+  listDir: (dirPath: string, opts?: { maxEntries?: number }) => Promise<unknown>
+  folderSize: (dirPath: string) => Promise<unknown>
+  largeFiles: (rootPath: string, minBytes: number, maxResults: number) => Promise<unknown>
+  processes: () => Promise<unknown>
+  services: () => Promise<unknown>
+  installed: () => Promise<unknown>
+  system: () => Promise<unknown>
+  network: () => Promise<unknown>
+  env: (keys?: string[]) => Promise<unknown>
+  startup: () => Promise<unknown>
+  temp: () => Promise<unknown>
+  tasks: () => Promise<unknown>
+  features: () => Promise<string>
+  openExplorer: (p: string) => Promise<void>
+  killProcess: (pid: number) => Promise<void>
+  openExternal: (url: string) => Promise<void>
+  clipboardWriteText: (text: string) => Promise<void>
+  notesGetAll: () => Promise<Record<string, string>>
+  notesSet: (key: string, value: string) => Promise<Record<string, string>>
+  notesDelete: (key: string) => Promise<Record<string, string>>
+}
+
+declare global {
+  interface Window {
+    auditor: AuditorBridge
+  }
+}
+
+export {}

src/index.css

@@ -0,0 +1,376 @@
+:root {
+  --bg: #0d0f12;
+  --bg-panel: #12151a;
+  --bg-elevated: #181c22;
+  --border: #2a3038;
+  --text: #e8eaed;
+  --text-muted: #8b939e;
+  --accent: #3d8fd1;
+  --accent-dim: #2a6a9a;
+  --danger: #c94c4c;
+  --row-hover: #1e242c;
+  --font: 'Segoe UI', system-ui, -apple-system, sans-serif;
+  --radius: 6px;
+  --sidebar-w: 220px;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+html,
+body,
+#root {
+  height: 100%;
+  margin: 0;
+}
+
+body {
+  font-family: var(--font);
+  font-size: 13px;
+  line-height: 1.45;
+  color: var(--text);
+  background: var(--bg);
+  -webkit-font-smoothing: antialiased;
+}
+
+.app-shell {
+  display: flex;
+  height: 100%;
+  min-height: 0;
+}
+
+.sidebar {
+  width: var(--sidebar-w);
+  flex-shrink: 0;
+  background: var(--bg-panel);
+  border-right: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  padding: 12px 0;
+}
+
+.sidebar-brand {
+  padding: 8px 16px 16px;
+  border-bottom: 1px solid var(--border);
+  margin-bottom: 8px;
+}
+
+.sidebar-brand h1 {
+  margin: 0;
+  font-size: 14px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  color: var(--text);
+}
+
+.sidebar-brand p {
+  margin: 4px 0 0;
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+.nav-item {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  width: 100%;
+  padding: 10px 16px;
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+  border-left: 3px solid transparent;
+}
+
+.nav-item:hover {
+  background: var(--row-hover);
+  color: var(--text);
+}
+
+.nav-item.active {
+  color: var(--text);
+  background: var(--bg-elevated);
+  border-left-color: var(--accent);
+}
+
+.nav-item svg {
+  flex-shrink: 0;
+  font-size: 16px;
+  opacity: 0.85;
+}
+
+.main {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+}
+
+.toolbar {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 16px;
+  background: var(--bg-panel);
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
+}
+
+.toolbar-spacer {
+  flex: 1;
+}
+
+.panel-title {
+  margin: 0;
+  font-size: 15px;
+  font-weight: 600;
+}
+
+.content-scroll {
+  flex: 1;
+  overflow: auto;
+  padding: 16px;
+  min-height: 0;
+}
+
+.card-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+  gap: 12px;
+}
+
+.card {
+  background: var(--bg-panel);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 14px 16px;
+}
+
+.card-label {
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-muted);
+  margin-bottom: 6px;
+}
+
+.card-value {
+  font-size: 18px;
+  font-weight: 600;
+}
+
+.card-sub {
+  margin-top: 4px;
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+table.data-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+}
+
+table.data-table th,
+table.data-table td {
+  padding: 8px 10px;
+  text-align: left;
+  border-bottom: 1px solid var(--border);
+}
+
+table.data-table th {
+  color: var(--text-muted);
+  font-weight: 500;
+  position: sticky;
+  top: 0;
+  background: var(--bg-elevated);
+  z-index: 1;
+}
+
+table.data-table tbody tr:hover {
+  background: var(--row-hover);
+}
+
+table.data-table tr.selected {
+  background: rgba(61, 143, 209, 0.12);
+}
+
+table.data-table td:last-child {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  align-items: center;
+}
+
+.mono {
+  font-family: ui-monospace, 'Cascadia Code', Consolas, monospace;
+  font-size: 11px;
+}
+
+.input-row {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+  align-items: center;
+  margin-bottom: 12px;
+}
+
+input[type='text'],
+input[type='search'],
+input[type='number'],
+textarea {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  color: var(--text);
+  padding: 8px 10px;
+  font: inherit;
+  min-width: 200px;
+}
+
+textarea {
+  width: 100%;
+  min-height: 100px;
+  resize: vertical;
+}
+
+input:focus,
+textarea:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.icon-btn-wrap {
+  position: relative;
+  display: inline-flex;
+  vertical-align: middle;
+}
+
+.icon-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 36px;
+  height: 36px;
+  padding: 0;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg-elevated);
+  color: var(--text);
+  cursor: pointer;
+}
+
+.icon-btn:hover:not(:disabled) {
+  border-color: var(--accent);
+  color: var(--accent);
+}
+
+.icon-btn:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+.icon-btn svg {
+  font-size: 18px;
+}
+
+.icon-btn-tooltip {
+  position: absolute;
+  left: 50%;
+  bottom: calc(100% + 8px);
+  transform: translateX(-50%);
+  padding: 4px 8px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-size: 11px;
+  white-space: nowrap;
+  color: var(--text);
+  opacity: 0;
+  pointer-events: none;
+  transition: opacity 0.12s ease;
+  z-index: 50;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.35);
+}
+
+.icon-btn-wrap:hover .icon-btn-tooltip {
+  opacity: 1;
+}
+
+.notes-panel {
+  border-top: 1px solid var(--border);
+  background: var(--bg-panel);
+  padding: 12px 16px;
+  flex-shrink: 0;
+  max-height: 180px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.notes-panel header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.notes-key {
+  font-size: 11px;
+  color: var(--text-muted);
+  word-break: break-all;
+}
+
+.bar-track {
+  height: 6px;
+  background: var(--border);
+  border-radius: 3px;
+  overflow: hidden;
+  margin-top: 8px;
+}
+
+.bar-fill {
+  height: 100%;
+  background: var(--accent);
+  border-radius: 3px;
+}
+
+.status-msg {
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.status-msg.error {
+  color: var(--danger);
+}
+
+.features-pre {
+  margin: 0;
+  padding: 12px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  overflow: auto;
+  max-height: 60vh;
+  font-size: 11px;
+  line-height: 1.4;
+}
+
+.checkbox-inline {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  color: var(--text-muted);
+  font-size: 12px;
+  user-select: none;
+}
+
+.checkbox-inline input {
+  accent-color: var(--accent);
+}

src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import App from './App'
+import './index.css'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+)

src/types.ts

@@ -0,0 +1,81 @@
+export interface DriveInfo {
+  letter: string
+  mount: string
+  label: string
+  totalBytes: number
+  freeBytes: number
+  usedBytes: number
+}
+
+export interface DirEntry {
+  name: string
+  fullPath: string
+  isDirectory: boolean
+  sizeBytes: number
+  mtimeMs: number
+  error?: string
+  sizeTruncated?: boolean
+}
+
+export interface ProcessRow {
+  pid: number
+  name: string
+  memoryBytes: number
+  cpuSeconds?: number
+  commandLine?: string
+}
+
+export interface ServiceRow {
+  name: string
+  displayName: string
+  state: string
+  startType: string
+}
+
+export interface InstalledApp {
+  name: string
+  version: string
+  publisher: string
+  installLocation: string
+  uninstallString: string
+  estimatedSizeKb: number
+}
+
+export interface NetworkRow {
+  name: string
+  address: string
+  family: string
+  internal: boolean
+  mac?: string
+}
+
+export interface SystemSnapshot {
+  hostname: string
+  platform: string
+  release: string
+  arch: string
+  uptimeSec: number
+  totalMem: number
+  freeMem: number
+  cpuModel: string
+  cpuCount: number
+  load1: number
+  load5: number
+  load15: number
+  userInfo: string
+  homedir: string
+  tmpdir: string
+}
+
+export type NavId =
+  | 'overview'
+  | 'storage'
+  | 'filesystem'
+  | 'processes'
+  | 'services'
+  | 'apps'
+  | 'network'
+  | 'environment'
+  | 'startup'
+  | 'scheduled'
+  | 'features'

src/utils/format.ts

@@ -0,0 +1,30 @@
+export function formatBytes(n: number): string {
+  if (!Number.isFinite(n) || n < 0) return '0 B'
+  const u = ['B', 'KB', 'MB', 'GB', 'TB']
+  let i = 0
+  let v = n
+  while (v >= 1024 && i < u.length - 1) {
+    v /= 1024
+    i++
+  }
+  return `${v < 10 && i > 0 ? v.toFixed(1) : Math.round(v)} ${u[i]}`
+}
+
+/** Exact size as decimal kilobytes (1 KB = 1024 bytes). Use + suffix when walk was capped. */
+export function formatSizeKb(bytes: number, opts?: { truncated?: boolean }): string {
+  if (!Number.isFinite(bytes) || bytes < 0) bytes = 0
+  const kb = bytes / 1024
+  const s = kb.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })
+  return opts?.truncated ? `${s}+ KB` : `${s} KB`
+}
+
+export function formatUptime(sec: number): string {
+  const d = Math.floor(sec / 86400)
+  const h = Math.floor((sec % 86400) / 3600)
+  const m = Math.floor((sec % 3600) / 60)
+  const parts: string[] = []
+  if (d) parts.push(`${d}d`)
+  if (h || d) parts.push(`${h}h`)
+  parts.push(`${m}m`)
+  return parts.join(' ')
+}

tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"]
+}

tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true
+  },
+  "include": ["vite.config.ts"]
+}

vite.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'node:path'
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, 'src'),
+    },
+  },
+  base: './',
+  build: {
+    outDir: 'dist',
+    emptyOutDir: true,
+  },
+})