preppergpt 0.1.2 → 0.1.4

package/README.md

@@ -6,9 +6,11 @@ uses upstream OpenWebUI for the app shell and adds a hardware detector, model
 planner, Docker Compose runtime, local sidecars, and a practical PrepperGPT
 field-kit theme.
 
-The first release targets Linux with NVIDIA GPUs first, with CPU fallback where
-possible. It is an online installer: model and container downloads require a
-working network during setup.
+PrepperGPT supports Linux first, including NVIDIA CUDA GPUs, Linux AMD ROCm
+GPUs, and CPU fallback where possible. Windows users should install and run it
+inside WSL2; native Windows installs are intentionally rejected until the native
+runtime path is reliable. It is an online installer: model and container
+downloads require a working network during setup.
 
 PrepperGPT optimizes for survivability over cloud-like latency. On very large
 local models, very low tokens/sec is acceptable because the alternative in the
@@ -16,11 +18,17 @@ target scenario is no assistant at all.
 
 ## Install
 
-Install from npm:
+Install and start from npm in one command:
 
 ```bash
-npx preppergpt install --profile balanced
-preppergpt start
+npx --yes preppergpt install --profile balanced --start
+```
+
+Or use two commands:
+
+```bash
+npx --yes preppergpt install --profile balanced
+npx --yes preppergpt start
 ```
 
 Or install globally:
@@ -40,11 +48,14 @@ node bin/preppergpt.js install --profile balanced
 node bin/preppergpt.js start
 ```
 
+Windows users should install Ubuntu in WSL2, enable Docker Desktop's WSL
+integration, and run the npm or GitHub install commands inside the WSL2 shell.
+
 Other profiles:
 
 ```bash
-preppergpt install --profile intelligence
-preppergpt install --profile speed
+npx --yes preppergpt install --profile intelligence
+npx --yes preppergpt install --profile speed
 ```
 
 Open the app at:
@@ -61,7 +72,7 @@ Change them before exposing the machine to any network.
 ```bash
 preppergpt detect
 preppergpt plan --profile balanced
-preppergpt install --profile balanced
+preppergpt install --profile balanced --start
 preppergpt start
 preppergpt stop
 preppergpt status
@@ -76,7 +87,8 @@ preppergpt bundle whisper
   machine, preferring GLM 5.2 Q8 on enterprise hardware, then GLM 5.2 Q4, then
   long-context coding routes when available.
 - `speed`: chooses smaller GPU-friendly routes and makes low-latency chat the
-  default.
+  default. NVIDIA hosts use CUDA container access; Linux AMD hosts use the
+  Ollama ROCm image and ROCm device mounts when ROCm is detected.
 - `balanced`: uses the local auto-router as the default and keeps reasoning,
   coding, research, vision, image, and STT routes additive.
 
@@ -95,6 +107,10 @@ GLM 5.2 Q8/Q4 and Flux weights are marked as manual or external in
 `profiles/models.json`. `preppergpt doctor` reports which selected routes still
 need local files or endpoints.
 
+AMD acceleration requires a Linux ROCm host with `rocm-smi` or `rocminfo`
+available. AMD cards detected without ROCm stay on CPU-compatible routes and
+receive a doctor warning instead of a broken GPU configuration.
+
 The GLM 5.2 Q8 route is intended for an enterprise/off-grid bunker-class host:
 large RAM, fast NVMe, and patience for slow local generation when no hosted
 service remains available.

package/compose/preppergpt.yaml

@@ -88,7 +88,7 @@ services:
       PORT: "${PREPPERGPT_PORT:-8080}"
 
   ollama:
-    image: ollama/ollama:latest
+    image: ${OLLAMA_IMAGE:-ollama/ollama:latest}
     container_name: preppergpt-ollama
     restart: unless-stopped
     network_mode: host
@@ -187,9 +187,6 @@ services:
     network_mode: host
     volumes:
       - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/local-agent:/data
-      - /tmp/.X11-unix:/tmp/.X11-unix:rw
-      - ${XDG_RUNTIME_DIR:-/run/user/1000}:${XDG_RUNTIME_DIR:-/run/user/1000}:rw
-      - ${XAUTHORITY:-/tmp/.preppergpt-missing-xauthority}:/tmp/.Xauthority:ro
     environment:
       LOCAL_AGENT_HOST: "127.0.0.1"
       LOCAL_AGENT_PORT: "18043"
@@ -210,7 +207,7 @@ services:
       LOCAL_AGENT_TIKA_URL: "http://127.0.0.1:9998/tika"
       LOCAL_AGENT_SCHEDULER_URL: "http://127.0.0.1:18042"
       LOCAL_AGENT_PLAYWRIGHT_WS_URL: "ws://127.0.0.1:18045"
-      LOCAL_AGENT_DESKTOP_ENABLED: "${LOCAL_AGENT_DESKTOP_ENABLED:-1}"
+      LOCAL_AGENT_DESKTOP_ENABLED: "${LOCAL_AGENT_DESKTOP_ENABLED:-0}"
       DISPLAY: "${DISPLAY:-}"
       WAYLAND_DISPLAY: "${WAYLAND_DISPLAY:-}"
       XDG_RUNTIME_DIR: "${XDG_RUNTIME_DIR:-/run/user/1000}"

package/docs/hardware.md

@@ -1,14 +1,19 @@
 # Hardware Guide
 
-PrepperGPT works best on Linux with an NVIDIA GPU and enough NVMe space for
-model weights. It is designed for post-apocalyptic or long-duration outage
-scenarios, so the high-end GLM tiers deliberately favor local availability and
-answer quality over hosted-service latency.
+PrepperGPT works best on Linux with a supported GPU and enough NVMe space for
+model weights. NVIDIA CUDA is supported, Linux AMD ROCm is supported when
+`rocm-smi` or `rocminfo` is available, and CPU fallback remains available for
+smaller routes. Windows users should run PrepperGPT inside WSL2; native Windows
+installs are rejected with WSL2 guidance. It is designed for post-apocalyptic or
+long-duration outage scenarios, so the high-end GLM tiers deliberately favor
+local availability and answer quality over hosted-service latency.
 
 Recommended starting points:
 
 - Speed profile: 16 GB RAM, 8-12 GB VRAM, 40 GB free disk.
 - Balanced profile: 32-64 GB RAM, 12-24 GB VRAM, 120 GB free disk.
+- Linux AMD ROCm profile: 32-128 GB RAM, 12-24+ GB AMD VRAM, ROCm tools
+  installed, and Docker access to `/dev/kfd` and `/dev/dri`.
 - Intelligence profile: 96 GB RAM or more, fast NVMe, and hundreds of GB free
   for GLM 5.2 Q4 or similar large weights.
 - Enterprise 8-bit GLM tier: 256 GB RAM or more, 48-80 GB VRAM preferred,
@@ -27,6 +32,9 @@ for situations where there is no cloud model to fall back to.
 | --- | --- | --- |
 | Basic CPU laptop | 16 GB RAM, no GPU, 80 GB disk | `local-chatgpt-auto`, `llama3.1:8b`, `local-vision-moondream2`, bundled Whisper |
 | Mid NVIDIA | 64 GB RAM, 12 GB usable VRAM, 250 GB disk | Gemma fast lane, Qwen coder fallback, local vision, bundled Whisper |
+| Mid AMD ROCm | 64 GB RAM, 12-24 GB usable AMD VRAM, ROCm on Linux, 250 GB disk | Ollama ROCm Gemma fast lane, Qwen coder fallback, local vision through Ollama, bundled Whisper |
+| AMD without ROCm | 32-64 GB RAM, AMD GPU detected, no ROCm tools | CPU-compatible routes plus a doctor warning to install ROCm for acceleration |
+| Windows WSL2 | 32+ GB RAM, Docker Desktop WSL integration, WSL2 Ubuntu | Linux-style install inside WSL2; native Windows install is rejected |
 | High NVIDIA | 128 GB RAM, 24 GB VRAM, 750 GB NVMe | GLM 5.2 Q4 configured, Slopcode/Qwen configured, Gemma fast lane, Flux configured |
 | Full PrepperGPT rig | 128+ GB RAM, 24+ GB VRAM, 1 TB NVMe, GLM/Slopcode/Flux files present | GLM 5.2 Q4 primary, Slopcode coding, Gemma fast lane, Deep Research, Agent, Vision, Flux, Whisper |
 | Enterprise 8-bit GLM rig | 256+ GB RAM, 48-80+ GB VRAM preferred, 1.5-2 TB fast NVMe | `glm52-q8-local` primary for Max Intelligence, `glm52-q4-local` fallback, Slopcode/Qwen coding, Gemma fast lane, full sidecar stack |

package/docs/model-sources.md

@@ -2,7 +2,9 @@
 
 PrepperGPT separates routing from model licensing and distribution.
 
-- Ollama models are pulled by the local Ollama runtime when available.
+- Ollama models are pulled by the local Ollama runtime when available. NVIDIA
+  hosts use the standard Ollama image; Linux AMD ROCm hosts use
+  `ollama/ollama:rocm` with `/dev/kfd` and `/dev/dri` exposed.
 - Whisper Base STT is installer-cached from `Systran/faster-whisper-base`
   under the local PrepperGPT model directory and mounted into OpenWebUI.
 - Hugging Face vision models are downloaded by the local vision sidecar.

package/docs/preppergpt-local-parity-map.md

@@ -14,5 +14,9 @@ local use when hosted AI services are unavailable:
 - Local vision sidecar at `http://127.0.0.1:18044/v1`
 - SearXNG, Tika, Jupyter, and ComfyUI support services
 
+Hardware support is additive: Linux NVIDIA uses CUDA container access, Linux AMD
+uses ROCm when available, CPU fallback remains available, and Windows support is
+through WSL2 rather than native Windows.
+
 The local goal is functional local parity for common ChatGPT workflows, not
 hosted frontier-model quality or cloud account continuity.

package/installer/cli.mjs

@@ -2,12 +2,12 @@ import fs from "node:fs";
 import http from "node:http";
 import { ensureWhisperBundle, modelDirs, whisperBundleStatus } from "./lib/bundles.mjs";
 import { detectMachine } from "./lib/detect.mjs";
-import { buildPlan, normalizeProfile } from "./lib/planner.mjs";
+import { buildPlan, installSupportError, normalizeProfile } from "./lib/planner.mjs";
 import { packageRoot, runtimePaths } from "./lib/paths.mjs";
 import { renderInstall } from "./lib/render.mjs";
 import { commandResult, parseArgs, readJson, shellQuote } from "./lib/util.mjs";
 
-const VERSION = "0.1.2";
+const VERSION = "0.1.4";
 
 function usage() {
   return `PrepperGPT ${VERSION}
@@ -15,7 +15,7 @@ function usage() {
 Usage:
   preppergpt detect [--json]
   preppergpt plan --profile balanced|intelligence|speed [--json]
-  preppergpt install --profile balanced|intelligence|speed [--dry-run] [--skip-bundles] [--home PATH]
+  preppergpt install --profile balanced|intelligence|speed [--start] [--dry-run] [--skip-bundles] [--home PATH]
   preppergpt start [--home PATH]
   preppergpt stop [--home PATH]
   preppergpt status [--home PATH] [--json]
@@ -34,6 +34,22 @@ function profileFrom(flags) {
   return normalizeProfile(flags.profile || flags.mode || "balanced");
 }
 
+function requiredToolStatuses(detection) {
+  return {
+    docker: Boolean(detection.tools?.docker),
+    dockerCompose: Boolean(detection.tools?.dockerCompose),
+    curl: Boolean(detection.tools?.curl),
+    "python3 or python": Boolean(detection.tools?.python3 || detection.tools?.python)
+  };
+}
+
+function assertSupportedInstall(detection) {
+  const message = installSupportError(detection);
+  if (message) {
+    throw new Error(message);
+  }
+}
+
 function composeArgs(paths) {
   return ["compose", "--env-file", paths.envFile, "-f", `${packageRoot}/compose/preppergpt.yaml`, "-f", paths.generatedCompose];
 }
@@ -88,19 +104,20 @@ async function commandDetect(flags) {
     printJson(detection);
     return;
   }
-  console.log(`Host: ${detection.hostname} (${detection.platform}/${detection.arch})`);
+  console.log(`Host: ${detection.hostname} (${detection.platformKind || detection.platform}/${detection.arch})`);
   console.log(`CPU: ${detection.cpu.cores} cores, ${detection.cpu.model}`);
   console.log(`RAM: ${detection.memory.totalGb} GB total, ${detection.memory.freeGb} GB free`);
   const bestDisk = detection.disks[0];
   console.log(`Disk: ${bestDisk ? `${bestDisk.freeGb.toFixed(1)} GB free at ${bestDisk.mount}` : "not detected"}`);
   if (detection.gpus.length) {
     for (const gpu of detection.gpus) {
-      console.log(`GPU ${gpu.index}: ${gpu.name}, ${gpu.totalVramGb} GB VRAM, ${gpu.freeVramGb} GB free`);
+      const memory = gpu.totalVramGb ? `${gpu.totalVramGb} GB VRAM, ${gpu.freeVramGb ?? "unknown"} GB free` : "VRAM unknown";
+      console.log(`GPU ${gpu.index}: ${gpu.vendor}/${gpu.runtime || "unknown"} ${gpu.name}, ${memory}`);
     }
   } else {
-    console.log("GPU: no NVIDIA GPU detected");
+    console.log("GPU: no supported GPU detected");
   }
-  const missing = Object.entries(detection.tools).filter(([, present]) => !present).map(([tool]) => tool);
+  const missing = Object.entries(requiredToolStatuses(detection)).filter(([, present]) => !present).map(([tool]) => tool);
   console.log(`Tools: ${missing.length ? `missing ${missing.join(", ")}` : "all required tools present"}`);
 }
 
@@ -117,9 +134,13 @@ async function commandPlan(flags) {
 async function commandInstall(flags) {
   const home = flags.home;
   const detection = await detectMachine();
+  assertSupportedInstall(detection);
   const plan = buildPlan(detection, profileFrom(flags));
   if (flags.dry_run) {
     printPlan(plan);
+    if (flags.start) {
+      console.log("\nWould start PrepperGPT after install.");
+    }
     console.log("\nDry run only. No files written.");
     return;
   }
@@ -132,14 +153,21 @@ async function commandInstall(flags) {
   console.log(`Wrote ${paths.envFile}`);
   console.log(`Wrote ${paths.generatedCompose}`);
   console.log(`Wrote ${paths.modelPlan}`);
+  if (flags.start) {
+    runCompose(paths, ["up", "-d"]);
+    console.log("\nPrepperGPT start requested.");
+    console.log("Open http://127.0.0.1:8080");
+    return;
+  }
   console.log("\nNext:");
-  console.log(`  preppergpt start --home ${shellQuote(paths.root)}`);
+  console.log(`  npx --yes preppergpt start --home ${shellQuote(paths.root)}`);
   console.log("  Open http://127.0.0.1:8080");
 }
 
 async function commandSwitchProfile(flags) {
   const paths = runtimePaths(flags.home);
   const detection = await detectMachine();
+  assertSupportedInstall(detection);
   const plan = buildPlan(detection, profileFrom(flags));
   renderInstall(plan, detection, { home: paths.root });
   console.log(`Switched PrepperGPT to ${plan.profile}.`);
@@ -199,9 +227,23 @@ async function commandDoctor(flags) {
   const plan = buildPlan(detection, profileFrom(flags));
   printPlan(plan);
   console.log("\nDoctor:");
-  const requiredTools = ["docker", "dockerCompose", "curl", "python3"];
-  for (const tool of requiredTools) {
-    console.log(`  ${tool}: ${detection.tools[tool] ? "ok" : "missing"}`);
+  const supportError = installSupportError(detection);
+  if (supportError) {
+    console.log(`  platform: unsupported (${supportError})`);
+  } else {
+    console.log(`  platform: ok (${detection.platformKind || detection.platform})`);
+  }
+  for (const [tool, present] of Object.entries(requiredToolStatuses(detection))) {
+    console.log(`  ${tool}: ${present ? "ok" : "missing"}`);
+  }
+  const amdGpu = detection.gpus.some((gpu) => gpu.vendor === "amd");
+  const nvidiaGpu = detection.gpus.some((gpu) => gpu.vendor === "nvidia");
+  if (nvidiaGpu) {
+    console.log(`  nvidia cuda: ${detection.tools.nvidiaSmi ? "ok" : "missing nvidia-smi"}`);
+  }
+  if (amdGpu) {
+    const rocmReady = detection.tools.rocmSmi || detection.tools.rocminfo;
+    console.log(`  amd rocm: ${rocmReady ? "ok" : "missing rocm-smi or rocminfo"}`);
   }
   for (const [port, entry] of Object.entries(detection.ports)) {
     if (!entry.free) {

package/installer/lib/detect.mjs

@@ -6,6 +6,31 @@ import { commandExists, commandResult, gb } from "./util.mjs";
 
 const DEFAULT_PORTS = [8080, 11434, 11438, 11441, 18041, 18042, 18043, 18044, 18045, 18080, 8188, 8888, 9998];
 
+function readFileMaybe(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+export function detectPlatformKind() {
+  if (process.platform === "win32") {
+    return "windows-native";
+  }
+  if (process.platform === "darwin") {
+    return "macos";
+  }
+  if (process.platform !== "linux") {
+    return "unknown";
+  }
+  const release = `${readFileMaybe("/proc/sys/kernel/osrelease")}\n${readFileMaybe("/proc/version")}`.toLowerCase();
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP || release.includes("microsoft") || release.includes("wsl")) {
+    return "wsl2";
+  }
+  return "linux";
+}
+
 function parseDf(target) {
   const result = commandResult("df", ["-Pk", target], { timeoutMs: 5000 });
   if (!result.ok) {
@@ -47,7 +72,57 @@ function candidateDiskPaths() {
   });
 }
 
-function detectGpus() {
+function usableVram(totalVramGb) {
+  return Math.round(totalVramGb * 0.82 * 10) / 10;
+}
+
+function normalizeGb(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.round(number * 10) / 10 : null;
+}
+
+function bytesToGb(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? normalizeGb(number / 1024 ** 3) : null;
+}
+
+function memoryToGb(value, fallbackUnit = "bytes") {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  const text = String(value).trim();
+  const matches = [...text.matchAll(/(\d+(?:\.\d+)?)/g)];
+  const number = Number(matches.at(-1)?.[1]);
+  if (!Number.isFinite(number)) {
+    return null;
+  }
+  const lower = text.toLowerCase();
+  if (/(gib|gb)/.test(lower)) {
+    return normalizeGb(number);
+  }
+  if (/(mib|mb)/.test(lower)) {
+    return normalizeGb(number / 1024);
+  }
+  if (/(kib|kb)/.test(lower)) {
+    return normalizeGb(number / 1024 / 1024);
+  }
+  if (/\(b\)|bytes?/.test(lower) || number > 1024 ** 3) {
+    return bytesToGb(number);
+  }
+  if (fallbackUnit === "mib" || number > 1024) {
+    return normalizeGb(number / 1024);
+  }
+  if (fallbackUnit === "bytes") {
+    return bytesToGb(number);
+  }
+  return normalizeGb(number);
+}
+
+function bestMatchingKey(record, patterns) {
+  return Object.keys(record).find((key) => patterns.some((pattern) => pattern.test(key)));
+}
+
+function detectNvidiaGpus() {
   if (!commandExists("nvidia-smi")) {
     return [];
   }
@@ -66,16 +141,199 @@ function detectGpus() {
       return {
         index,
         vendor: "nvidia",
+        runtime: "cuda",
         name,
-        totalVramGb: Math.round((Number(totalMiB) / 1024) * 10) / 10,
-        freeVramGb: Math.round((Number(freeMiB) / 1024) * 10) / 10,
-        usableVramGb: Math.round((Number(totalMiB) / 1024) * 0.82 * 10) / 10,
+        totalVramGb: normalizeGb(Number(totalMiB) / 1024),
+        freeVramGb: normalizeGb(Number(freeMiB) / 1024),
+        usableVramGb: usableVram(Number(totalMiB) / 1024),
         driver
       };
     })
     .filter((gpu) => gpu.name && Number.isFinite(gpu.totalVramGb));
 }
 
+function detectAmdRocmSmiGpus() {
+  if (!commandExists("rocm-smi")) {
+    return [];
+  }
+  const jsonResult = commandResult("rocm-smi", [
+    "--showproductname",
+    "--showmeminfo",
+    "vram",
+    "--showdriverversion",
+    "--json"
+  ]);
+  if (jsonResult.ok) {
+    try {
+      const parsed = JSON.parse(jsonResult.stdout);
+      return Object.entries(parsed)
+        .filter(([id, record]) => /^card\d+/i.test(id) && record && typeof record === "object")
+        .map(([id, record], index) => {
+          const totalKey = bestMatchingKey(record, [/vram.*total/i, /total.*memory/i]);
+          const usedKey = bestMatchingKey(record, [/vram.*used/i, /used.*memory/i]);
+          const nameKey = bestMatchingKey(record, [/product.*name/i, /card.*series/i, /marketing.*name/i]);
+          const driverKey = bestMatchingKey(record, [/driver/i]);
+          const totalVramGb = memoryToGb(record[totalKey]);
+          const usedVramGb = memoryToGb(record[usedKey]) || 0;
+          const freeVramGb = totalVramGb === null ? null : normalizeGb(Math.max(totalVramGb - usedVramGb, 0));
+          return {
+            index,
+            vendor: "amd",
+            runtime: "rocm",
+            name: String(record[nameKey] || id),
+            totalVramGb,
+            freeVramGb,
+            usableVramGb: totalVramGb === null ? null : usableVram(totalVramGb),
+            driver: String(record[driverKey] || "")
+          };
+        })
+        .filter((gpu) => gpu.name);
+    } catch {
+      // Fall through to text parsing.
+    }
+  }
+
+  const textResult = commandResult("rocm-smi", ["--showproductname", "--showmeminfo", "vram", "--showdriverversion"]);
+  if (!textResult.ok) {
+    return [];
+  }
+  const cards = new Map();
+  for (const line of textResult.stdout.split(/\n/)) {
+    const match = line.match(/(card\d+)\s*[:\t ]+(.*)$/i);
+    if (!match) {
+      continue;
+    }
+    const [, id, value] = match;
+    const record = cards.get(id) || {};
+    if (/product|series|marketing/i.test(value)) {
+      record.name = value.split(/[:=]/).at(-1)?.trim() || record.name;
+    }
+    if (/total.*vram|vram.*total/i.test(value)) {
+      record.totalVramGb = memoryToGb(value);
+    }
+    if (/used.*vram|vram.*used/i.test(value)) {
+      record.usedVramGb = memoryToGb(value);
+    }
+    if (/driver/i.test(value)) {
+      record.driver = value.split(/[:=]/).at(-1)?.trim();
+    }
+    cards.set(id, record);
+  }
+  return [...cards.entries()].map(([id, record], index) => {
+    const totalVramGb = record.totalVramGb ?? null;
+    const freeVramGb =
+      totalVramGb === null ? null : normalizeGb(Math.max(totalVramGb - (record.usedVramGb || 0), 0));
+    return {
+      index,
+      vendor: "amd",
+      runtime: "rocm",
+      name: record.name || id,
+      totalVramGb,
+      freeVramGb,
+      usableVramGb: totalVramGb === null ? null : usableVram(totalVramGb),
+      driver: record.driver || ""
+    };
+  });
+}
+
+function detectAmdRocinfoGpus() {
+  if (!commandExists("rocminfo")) {
+    return [];
+  }
+  const result = commandResult("rocminfo", [], { timeoutMs: 8000 });
+  if (!result.ok) {
+    return [];
+  }
+  const names = [];
+  for (const line of result.stdout.split(/\n/)) {
+    const match = line.match(/^\s*(?:Marketing Name|Name):\s*(.+)$/);
+    if (match && /amd|radeon|instinct|gfx/i.test(match[1])) {
+      names.push(match[1].trim());
+    }
+  }
+  return [...new Set(names)].map((name, index) => ({
+    index,
+    vendor: "amd",
+    runtime: "rocm",
+    name,
+    totalVramGb: null,
+    freeVramGb: null,
+    usableVramGb: null,
+    driver: ""
+  }));
+}
+
+export function parseLspciMachineLine(line) {
+  const fields = [];
+  const pattern = /"([^"]*)"|(\S+)/g;
+  let match = pattern.exec(line);
+  while (match) {
+    fields.push(match[1] ?? match[2]);
+    match = pattern.exec(line);
+  }
+  return fields;
+}
+
+function isDisplayController(value) {
+  return /^(VGA compatible controller|3D controller|Display controller)$/i.test(value || "");
+}
+
+function isAmdVendor(value) {
+  return /\b(Advanced Micro Devices|AMD|AMD\/ATI|ATI Technologies)\b/i.test(value || "");
+}
+
+export function amdPciGpuFromLspciLine(line, index = 0) {
+  const fields = parseLspciMachineLine(line);
+  const [, className, vendor, device] = fields;
+  if (!isDisplayController(className) || !isAmdVendor(vendor)) {
+    return null;
+  }
+  return {
+    index,
+    vendor: "amd",
+    runtime: "none",
+    name: [vendor, device].filter(Boolean).join(" ").trim() || "AMD GPU",
+    totalVramGb: null,
+    freeVramGb: null,
+    usableVramGb: null,
+    driver: ""
+  };
+}
+
+function detectAmdPciGpus() {
+  if (!commandExists("lspci")) {
+    return [];
+  }
+  const result = commandResult("lspci", ["-mm"], { timeoutMs: 5000 });
+  if (!result.ok) {
+    return [];
+  }
+  return result.stdout
+    .split(/\n/)
+    .map((line, index) => amdPciGpuFromLspciLine(line, index))
+    .filter(Boolean);
+}
+
+function dedupeGpus(gpus) {
+  const seen = new Set();
+  return gpus.filter((gpu) => {
+    const key = `${gpu.vendor}:${gpu.name}:${gpu.totalVramGb ?? "unknown"}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+function detectGpus() {
+  const nvidia = detectNvidiaGpus();
+  const amdRocm = detectAmdRocmSmiGpus();
+  const amdFallback = amdRocm.length ? [] : detectAmdRocinfoGpus();
+  const amdPci = amdRocm.length || amdFallback.length ? [] : detectAmdPciGpus();
+  return dedupeGpus([...nvidia, ...amdRocm, ...amdFallback, ...amdPci]);
+}
+
 async function portFree(port) {
   return new Promise((resolve) => {
     const server = net.createServer();
@@ -93,6 +351,7 @@ async function detectPorts(ports = DEFAULT_PORTS) {
 }
 
 export async function detectMachine(options = {}) {
+  const platformKind = detectPlatformKind();
   const disks = candidateDiskPaths()
     .map(parseDf)
     .filter(Boolean)
@@ -104,12 +363,17 @@ export async function detectMachine(options = {}) {
     tmux: commandExists("tmux"),
     curl: commandExists("curl"),
     python3: commandExists("python3"),
+    python: commandExists("python"),
     git: commandExists("git"),
-    nvidiaSmi: commandExists("nvidia-smi")
+    nvidiaSmi: commandExists("nvidia-smi"),
+    rocmSmi: commandExists("rocm-smi"),
+    rocminfo: commandExists("rocminfo")
   };
   return {
     generatedAt: new Date().toISOString(),
     platform: process.platform,
+    platformKind,
+    isWsl2: platformKind === "wsl2",
     arch: process.arch,
     hostname: os.hostname(),
     cpu: {

package/installer/lib/planner.mjs

@@ -23,18 +23,57 @@ function bestDisk(detection) {
   return detection.disks?.[0] || { freeGb: 0, isNvme: false, path: "" };
 }
 
-function bestGpu(detection) {
-  return [...(detection.gpus || [])].sort((a, b) => b.usableVramGb - a.usableVramGb)[0] || null;
+function detectedPlatformKind(detection) {
+  if (detection.platformKind) {
+    return detection.platformKind;
+  }
+  if (detection.platform === "win32") {
+    return "windows-native";
+  }
+  if (detection.platform === "darwin") {
+    return "macos";
+  }
+  return detection.platform || "unknown";
+}
+
+function bestGpu(detection, vendors = null) {
+  const allowed = vendors ? new Set(vendors) : null;
+  return [...(detection.gpus || [])]
+    .filter((gpu) => !allowed || allowed.has(gpu.vendor))
+    .sort((a, b) => (b.usableVramGb || 0) - (a.usableVramGb || 0))[0] || null;
+}
+
+function gpuVendorLabel(vendors) {
+  if (!vendors?.length) {
+    return "supported";
+  }
+  return vendors.map((vendor) => (vendor === "nvidia" ? "NVIDIA" : vendor === "amd" ? "AMD" : vendor)).join("/");
+}
+
+function hasRocmRuntime(detection) {
+  return Boolean(detection.tools?.rocmSmi || detection.tools?.rocminfo);
+}
+
+export function installSupportError(detection) {
+  if (detectedPlatformKind(detection) === "windows-native") {
+    return "Native Windows install is not supported yet. Install PrepperGPT inside WSL2 so Docker, Linux paths, and local model services use the supported Linux runtime.";
+  }
+  return null;
 }
 
 function requirementFailures(model, detection) {
   const requires = model.requires || {};
   const disk = bestDisk(detection);
-  const gpu = bestGpu(detection);
+  const platformKind = detectedPlatformKind(detection);
+  const gpuVendors = requires.gpuVendors || null;
+  const gpu = bestGpu(detection, gpuVendors);
   const failures = [];
   if (requires.platforms && !requires.platforms.includes(detection.platform)) {
     failures.push(`requires platform ${requires.platforms.join(", ")}`);
   }
+  if (requires.platformKinds && !requires.platformKinds.includes(platformKind)) {
+    failures.push(`requires platform kind ${requires.platformKinds.join(", ")}`);
+  }
   if (requires.minRamGb && detection.memory.totalGb < requires.minRamGb) {
     failures.push(`requires ${requires.minRamGb} GB RAM`);
   }
@@ -44,11 +83,22 @@ function requirementFailures(model, detection) {
   if (requires.nvme && disk.freeGb >= (requires.diskGb || 0) && !disk.isNvme) {
     failures.push("strongly prefers NVMe for acceptable load time");
   }
+  if (requires.gpuVendors && detection.gpus?.length && !gpu) {
+    failures.push(`requires ${gpuVendorLabel(requires.gpuVendors)} GPU`);
+  }
   if (requires.gpu && !gpu) {
-    failures.push("requires NVIDIA GPU");
+    failures.push(`requires ${gpuVendorLabel(requires.gpuVendors)} GPU`);
   }
   if (requires.minVramGb && (!gpu || gpu.usableVramGb < requires.minVramGb)) {
-    failures.push(`requires about ${requires.minVramGb} GB usable VRAM`);
+    failures.push(`requires ${gpuVendorLabel(requires.gpuVendors)} GPU with about ${requires.minVramGb} GB usable VRAM`);
+  }
+  if (requires.requiresRocm && gpu?.vendor === "amd") {
+    if (platformKind !== "linux") {
+      failures.push("requires a Linux ROCm host for AMD GPU acceleration");
+    }
+    if (gpu.runtime !== "rocm" || !hasRocmRuntime(detection)) {
+      failures.push("requires ROCm runtime tools for AMD GPU acceleration");
+    }
   }
   return failures;
 }
@@ -116,9 +166,16 @@ export function buildPlan(detection, requestedProfile = "balanced", catalog = lo
     }));
 
   const warnings = [];
+  const installError = installSupportError(detection);
+  if (installError) {
+    warnings.push(installError);
+  }
   const missingTools = Object.entries(detection.tools || {})
-    .filter(([tool, present]) => ["docker", "dockerCompose", "curl", "python3"].includes(tool) && !present)
+    .filter(([tool, present]) => ["docker", "dockerCompose", "curl"].includes(tool) && !present)
     .map(([tool]) => tool);
+  if (!detection.tools?.python3 && !detection.tools?.python) {
+    missingTools.push("python3 or python");
+  }
   if (missingTools.length) {
     warnings.push(`Missing required tools: ${missingTools.join(", ")}`);
   }
@@ -128,8 +185,18 @@ export function buildPlan(detection, requestedProfile = "balanced", catalog = lo
   if (occupiedPorts.length) {
     warnings.push(`Ports already in use: ${occupiedPorts.join(", ")}`);
   }
-  if (!detection.gpus?.length) {
-    warnings.push("No NVIDIA GPU detected; CPU fallback will be much slower.");
+  const acceleratedGpu = (detection.gpus || []).find(
+    (gpu) => gpu.vendor === "nvidia" || (gpu.vendor === "amd" && gpu.runtime === "rocm" && detectedPlatformKind(detection) === "linux")
+  );
+  if (!acceleratedGpu) {
+    warnings.push("No supported GPU acceleration detected; CPU fallback will be much slower.");
+  }
+  const amdWithoutRocm = (detection.gpus || []).some((gpu) => gpu.vendor === "amd" && gpu.runtime !== "rocm");
+  if (amdWithoutRocm) {
+    warnings.push("AMD GPU detected without ROCm; install ROCm on Linux to enable AMD acceleration.");
+  }
+  if ((detection.gpus || []).some((gpu) => gpu.vendor === "amd") && detectedPlatformKind(detection) === "wsl2") {
+    warnings.push("AMD GPU acceleration is supported on Linux ROCm hosts; WSL2 installs will use CPU fallback unless an external AMD endpoint is provided.");
   }
   if (manualAssets.length) {
     warnings.push("Some selected high-quality routes need manual model files or already-running external endpoints.");

package/installer/lib/render.mjs

@@ -9,10 +9,39 @@ function secret(bytes = 24) {
   return crypto.randomBytes(bytes).toString("hex");
 }
 
+function platformKind(detection) {
+  return detection.platformKind || (detection.platform === "win32" ? "windows-native" : detection.platform || "unknown");
+}
+
+function primaryAccelerator(detection) {
+  const gpus = detection.gpus || [];
+  const nvidia = gpus.find((gpu) => gpu.vendor === "nvidia");
+  if (nvidia) {
+    return { vendor: "nvidia", runtime: "cuda" };
+  }
+  const amdRocm = gpus.find((gpu) => gpu.vendor === "amd" && gpu.runtime === "rocm");
+  if (amdRocm && platformKind(detection) === "linux") {
+    return { vendor: "amd", runtime: "rocm" };
+  }
+  return { vendor: "cpu", runtime: "cpu" };
+}
+
+function desktopIntegrationEnabled(detection) {
+  const explicit = String(process.env.LOCAL_AGENT_DESKTOP_ENABLED || "").toLowerCase();
+  if (["0", "false", "no", "off"].includes(explicit)) {
+    return false;
+  }
+  const kind = platformKind(detection);
+  const platformSupportsDesktop = kind === "linux" || kind === "wsl2";
+  const hasDisplay = Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+  return platformSupportsDesktop && hasDisplay && explicit !== "0";
+}
+
 function envFile(plan, paths, detection) {
   const dataDir = process.env.PREPPERGPT_DATA_DIR || paths.dataDir;
   const modelsDir = process.env.PREPPERGPT_MODELS_DIR || `${dataDir}/models`;
   const whisperHostDir = path.join(modelsDir, "whisper", "base");
+  const accelerator = primaryAccelerator(detection);
   const selectedReasoningModel = plan.selected?.reasoning?.id || "glm52-q4-local";
   const selectedGlmBaseUrl =
     selectedReasoningModel === "glm52-q8-local"
@@ -33,7 +62,10 @@ function envFile(plan, paths, detection) {
     PREPPERGPT_MODEL_ORDER_LIST: JSON.stringify(plan.routeIds),
     PREPPERGPT_GLM_MODEL: selectedReasoningModel,
     PREPPERGPT_GLM_BASE_URL: selectedGlmBaseUrl,
-    PREPPERGPT_DOCKER_GPUS: detection.gpus?.length ? "all" : "",
+    PREPPERGPT_GPU_VENDOR: accelerator.vendor,
+    PREPPERGPT_ACCELERATOR: accelerator.runtime,
+    PREPPERGPT_DOCKER_GPUS: accelerator.vendor === "nvidia" ? "all" : "",
+    OLLAMA_IMAGE: accelerator.vendor === "amd" ? "ollama/ollama:rocm" : "ollama/ollama:latest",
     WEBUI_NAME: "PrepperGPT",
     WEBUI_ADMIN_EMAIL: process.env.WEBUI_ADMIN_EMAIL || "admin@preppergpt.local",
     WEBUI_ADMIN_PASSWORD: adminPassword,
@@ -53,13 +85,38 @@ function envFile(plan, paths, detection) {
 
 function generatedCompose(plan, detection) {
   const modelOrder = JSON.stringify(plan.routeIds);
-  const gpuBlock = detection.gpus?.length
-    ? [
+  const accelerator = primaryAccelerator(detection);
+  const gpuBlock =
+    accelerator.vendor === "nvidia"
+      ? [
         "  ollama:",
         "    gpus: all",
         "  local-vision:",
         "    gpus: all"
       ]
+      : accelerator.vendor === "amd"
+        ? [
+            "  ollama:",
+            "    devices:",
+            "      - /dev/kfd:/dev/kfd",
+            "      - /dev/dri:/dev/dri",
+            "    group_add:",
+            "      - video",
+            "      - render",
+            "    security_opt:",
+            "      - seccomp=unconfined"
+          ]
+        : [];
+  const desktopBlock = desktopIntegrationEnabled(detection)
+    ? [
+        "  local-agent:",
+        "    environment:",
+        "      LOCAL_AGENT_DESKTOP_ENABLED: \"1\"",
+        "    volumes:",
+        "      - /tmp/.X11-unix:/tmp/.X11-unix:rw",
+        "      - ${XDG_RUNTIME_DIR:-/run/user/1000}:${XDG_RUNTIME_DIR:-/run/user/1000}:rw",
+        "      - ${XAUTHORITY:-/tmp/.preppergpt-missing-xauthority}:/tmp/.Xauthority:ro"
+      ]
     : [];
   return [
     "services:",
@@ -68,7 +125,8 @@ function generatedCompose(plan, detection) {
     `      DEFAULT_MODELS: "${plan.defaultModel}"`,
     `      MODEL_ORDER_LIST: '${modelOrder.replaceAll("'", "''")}'`,
     `      TASK_MODEL: "${plan.selected.fast?.id || plan.defaultModel}"`,
-    ...gpuBlock
+    ...gpuBlock,
+    ...desktopBlock
   ].join("\n") + "\n";
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preppergpt",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "A post-apocalyptic local AI field kit for running a ChatGPT-like experience when hosted services are unavailable.",
   "type": "module",
   "bin": {

package/profiles/models.json

@@ -131,16 +131,18 @@
       "contextTokens": 262144,
       "qualityScore": 78,
       "speedScore": 96,
-      "tpsEstimate": "35-90 completion tokens/sec on a modern 16-24 GB NVIDIA GPU",
+      "tpsEstimate": "35-90 completion tokens/sec on a modern 16-24 GB NVIDIA GPU or supported Linux AMD ROCm GPU",
       "requires": {
         "minRamGb": 24,
         "minVramGb": 11,
-        "diskGb": 20
+        "diskGb": 20,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "ollama",
         "model": "gemma4:12b",
-        "description": "Pulled or provided through the local Ollama server."
+        "description": "Pulled or provided through the local Ollama server. AMD hosts use the Ollama ROCm container when ROCm is detected on Linux."
       }
     },
     {
@@ -151,16 +153,18 @@
       "contextTokens": 32768,
       "qualityScore": 76,
       "speedScore": 75,
-      "tpsEstimate": "12-45 completion tokens/sec depending on GPU and quantization",
+      "tpsEstimate": "12-45 completion tokens/sec depending on GPU vendor, ROCm/CUDA readiness, and quantization",
       "requires": {
         "minRamGb": 24,
         "minVramGb": 10,
-        "diskGb": 16
+        "diskGb": 16,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "ollama",
         "model": "qwen2.5-coder:14b",
-        "description": "Ollama coding fallback."
+        "description": "Ollama coding fallback. AMD hosts use the Ollama ROCm container when ROCm is detected on Linux."
       }
     },
     {
@@ -230,7 +234,9 @@
       "requires": {
         "minRamGb": 24,
         "minVramGb": 11,
-        "diskGb": 20
+        "diskGb": 20,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "virtual",
@@ -268,11 +274,13 @@
       "requires": {
         "minRamGb": 32,
         "minVramGb": 16,
-        "diskGb": 60
+        "diskGb": 60,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "manual",
-        "description": "Place Flux model, text encoder, and VAE files in the configured ComfyUI models directory."
+        "description": "Place Flux model, text encoder, and VAE files in the configured ComfyUI models directory. Use a CUDA or Linux ROCm ComfyUI runtime that matches the host GPU."
       }
     },
     {