preppergpt 0.1.0

package/installer/lib/detect.mjs

@@ -0,0 +1,128 @@
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { commandExists, commandResult, gb } from "./util.mjs";
+
+const DEFAULT_PORTS = [8080, 11434, 11438, 11441, 18041, 18042, 18043, 18044, 18045, 18080, 8188, 8888, 9998];
+
+function parseDf(target) {
+  const result = commandResult("df", ["-Pk", target], { timeoutMs: 5000 });
+  if (!result.ok) {
+    return null;
+  }
+  const lines = result.stdout.trim().split(/\n/);
+  const fields = lines.at(-1)?.trim().split(/\s+/);
+  if (!fields || fields.length < 6) {
+    return null;
+  }
+  return {
+    path: target,
+    filesystem: fields[0],
+    sizeGb: Number(fields[1]) / 1024 / 1024,
+    usedGb: Number(fields[2]) / 1024 / 1024,
+    freeGb: Number(fields[3]) / 1024 / 1024,
+    mount: fields[5],
+    isNvme: fields[0].includes("nvme") || fields[5].toLowerCase().includes("nvme")
+  };
+}
+
+function candidateDiskPaths() {
+  const candidates = [
+    process.env.PREPPERGPT_MODELS_DIR,
+    process.env.PREPPERGPT_DATA_DIR,
+    path.join(os.homedir(), ".preppergpt"),
+    "/models",
+    "/data",
+    "/mnt",
+    "/media",
+    process.cwd()
+  ].filter(Boolean);
+  return [...new Set(candidates)].filter((candidate) => {
+    try {
+      return fs.existsSync(candidate) || fs.existsSync(path.dirname(candidate));
+    } catch {
+      return false;
+    }
+  });
+}
+
+function detectGpus() {
+  if (!commandExists("nvidia-smi")) {
+    return [];
+  }
+  const result = commandResult("nvidia-smi", [
+    "--query-gpu=name,memory.total,memory.free,driver_version",
+    "--format=csv,noheader,nounits"
+  ]);
+  if (!result.ok) {
+    return [];
+  }
+  return result.stdout
+    .trim()
+    .split(/\n/)
+    .map((line, index) => {
+      const [name, totalMiB, freeMiB, driver] = line.split(",").map((part) => part.trim());
+      return {
+        index,
+        vendor: "nvidia",
+        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,
+        driver
+      };
+    })
+    .filter((gpu) => gpu.name && Number.isFinite(gpu.totalVramGb));
+}
+
+async function portFree(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+
+async function detectPorts(ports = DEFAULT_PORTS) {
+  const entries = await Promise.all(ports.map(async (port) => [port, await portFree(port)]));
+  return Object.fromEntries(entries.map(([port, free]) => [String(port), { port, free }]));
+}
+
+export async function detectMachine(options = {}) {
+  const disks = candidateDiskPaths()
+    .map(parseDf)
+    .filter(Boolean)
+    .sort((a, b) => b.freeGb - a.freeGb);
+  const gpus = detectGpus();
+  const tools = {
+    docker: commandExists("docker"),
+    dockerCompose: commandResult("docker", ["compose", "version"], { timeoutMs: 5000 }).ok,
+    tmux: commandExists("tmux"),
+    curl: commandExists("curl"),
+    python3: commandExists("python3"),
+    git: commandExists("git"),
+    nvidiaSmi: commandExists("nvidia-smi")
+  };
+  return {
+    generatedAt: new Date().toISOString(),
+    platform: process.platform,
+    arch: process.arch,
+    hostname: os.hostname(),
+    cpu: {
+      model: os.cpus()[0]?.model || "unknown",
+      cores: os.cpus().length
+    },
+    memory: {
+      totalGb: gb(os.totalmem()),
+      freeGb: gb(os.freemem())
+    },
+    disks,
+    gpus,
+    tools,
+    ports: options.skipPorts ? {} : await detectPorts(options.ports || DEFAULT_PORTS)
+  };
+}

package/installer/lib/paths.mjs

@@ -0,0 +1,26 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+
+export function defaultHome() {
+  return path.resolve(process.env.PREPPERGPT_HOME || path.join(os.homedir(), ".preppergpt"));
+}
+
+export function runtimePaths(home = defaultHome()) {
+  const root = path.resolve(home);
+  return {
+    root,
+    envFile: path.join(root, ".env.preppergpt"),
+    dataDir: path.join(root, "data"),
+    composeDir: path.join(root, "compose"),
+    generatedCompose: path.join(root, "compose", "generated.models.yaml"),
+    modelPlan: path.join(root, "data", "preppergpt", "model-plan.json"),
+    detectReport: path.join(root, "data", "preppergpt", "hardware-detect.json")
+  };
+}
+
+export function packagedPath(...parts) {
+  return path.join(packageRoot, ...parts);
+}

package/installer/lib/planner.mjs

@@ -0,0 +1,175 @@
+import { packagedPath } from "./paths.mjs";
+import { readJson, unique } from "./util.mjs";
+
+export function loadCatalog() {
+  return readJson(packagedPath("profiles", "models.json"));
+}
+
+export function normalizeProfile(profile) {
+  const value = String(profile || "balanced").toLowerCase();
+  if (["intelligence", "max-intelligence", "max_intelligence", "smart", "quality"].includes(value)) {
+    return "intelligence";
+  }
+  if (["speed", "max-speed", "max_speed", "fast"].includes(value)) {
+    return "speed";
+  }
+  if (["balanced", "balance", "middle", "middle-ground", "middle_ground"].includes(value)) {
+    return "balanced";
+  }
+  throw new Error(`Unknown profile: ${profile}`);
+}
+
+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 requirementFailures(model, detection) {
+  const requires = model.requires || {};
+  const disk = bestDisk(detection);
+  const gpu = bestGpu(detection);
+  const failures = [];
+  if (requires.platforms && !requires.platforms.includes(detection.platform)) {
+    failures.push(`requires platform ${requires.platforms.join(", ")}`);
+  }
+  if (requires.minRamGb && detection.memory.totalGb < requires.minRamGb) {
+    failures.push(`requires ${requires.minRamGb} GB RAM`);
+  }
+  if (requires.diskGb && disk.freeGb < requires.diskGb) {
+    failures.push(`requires ${requires.diskGb} GB free disk`);
+  }
+  if (requires.nvme && disk.freeGb >= (requires.diskGb || 0) && !disk.isNvme) {
+    failures.push("strongly prefers NVMe for acceptable load time");
+  }
+  if (requires.gpu && !gpu) {
+    failures.push("requires NVIDIA GPU");
+  }
+  if (requires.minVramGb && (!gpu || gpu.usableVramGb < requires.minVramGb)) {
+    failures.push(`requires about ${requires.minVramGb} GB usable VRAM`);
+  }
+  return failures;
+}
+
+function chooseFirst(candidates, models, detection) {
+  const skipped = [];
+  for (const id of candidates) {
+    const model = models.get(id);
+    if (!model) {
+      skipped.push({ id, reasons: ["not in catalog"] });
+      continue;
+    }
+    const failures = requirementFailures(model, detection);
+    if (failures.length === 0 || model.source?.type === "manual" || model.source?.type === "external") {
+      return { model, skipped };
+    }
+    skipped.push({ id, reasons: failures });
+  }
+  return { model: null, skipped };
+}
+
+export function buildPlan(detection, requestedProfile = "balanced", catalog = loadCatalog()) {
+  const profile = normalizeProfile(requestedProfile);
+  const models = new Map(catalog.models.map((model) => [model.id, model]));
+  const priorities = catalog.profiles[profile];
+  const selected = {};
+  const skipped = {};
+
+  for (const [role, candidates] of Object.entries(priorities.roles)) {
+    const choice = chooseFirst(candidates, models, detection);
+    if (choice.model) {
+      selected[role] = {
+        ...choice.model,
+        requirementWarnings: requirementFailures(choice.model, detection),
+        needsManualAssets: ["manual", "external"].includes(choice.model.source?.type)
+      };
+    }
+    if (choice.skipped.length) {
+      skipped[role] = choice.skipped;
+    }
+  }
+
+  const routeIds = unique([
+    priorities.defaultModel,
+    selected.chat?.id,
+    selected.fast?.id,
+    selected.reasoning?.id,
+    selected.coding?.id,
+    selected.research?.id,
+    selected.agent?.id,
+    selected.vision?.id,
+    selected.image?.id,
+    selected.stt?.id
+  ]);
+
+  const manualAssets = Object.values(selected)
+    .filter((model) => model.needsManualAssets)
+    .map((model) => ({
+      id: model.id,
+      source: model.source,
+      reason: model.source?.description || "manual or external source"
+    }));
+
+  const warnings = [];
+  const missingTools = Object.entries(detection.tools || {})
+    .filter(([tool, present]) => ["docker", "dockerCompose", "curl", "python3"].includes(tool) && !present)
+    .map(([tool]) => tool);
+  if (missingTools.length) {
+    warnings.push(`Missing required tools: ${missingTools.join(", ")}`);
+  }
+  const occupiedPorts = Object.values(detection.ports || {})
+    .filter((entry) => !entry.free)
+    .map((entry) => entry.port);
+  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.");
+  }
+  if (manualAssets.length) {
+    warnings.push("Some selected high-quality routes need manual model files or already-running external endpoints.");
+  }
+
+  return {
+    generatedAt: new Date().toISOString(),
+    profile,
+    profileLabel: priorities.label,
+    defaultModel: priorities.defaultModel,
+    routeIds,
+    selected,
+    skipped,
+    manualAssets,
+    estimates: estimatePlan(profile, selected),
+    env: {
+      PREPPERGPT_PROFILE: profile,
+      PREPPERGPT_DEFAULT_MODEL: priorities.defaultModel,
+      PREPPERGPT_MODEL_ORDER_LIST: JSON.stringify(routeIds)
+    },
+    warnings
+  };
+}
+
+function estimatePlan(profile, selected) {
+  const chat = selected.chat || selected.fast || selected.reasoning;
+  const fast = selected.fast || chat;
+  const contextTokens = Math.max(
+    ...Object.values(selected)
+      .map((model) => model.contextTokens || 0)
+      .filter(Boolean),
+    0
+  );
+  return {
+    defaultContextTokens: chat?.contextTokens || 8192,
+    maxContextTokens: contextTokens || 8192,
+    defaultTpsEstimate: chat?.tpsEstimate || "unknown until benchmarked",
+    bestTpsEstimate: fast?.tpsEstimate || "unknown until benchmarked",
+    note:
+      profile === "intelligence"
+        ? "Max intelligence favors quality and context over latency."
+        : profile === "speed"
+          ? "Max speed favors low-latency routes over largest weights."
+          : "Middle ground uses the local auto-router and keeps specialist routes additive."
+  };
+}

package/installer/lib/render.mjs

@@ -0,0 +1,76 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { packagedPath, runtimePaths } from "./paths.mjs";
+import { envQuote, writeJson, writeText } from "./util.mjs";
+
+function secret(bytes = 24) {
+  return crypto.randomBytes(bytes).toString("hex");
+}
+
+function envFile(plan, paths, detection) {
+  const dataDir = process.env.PREPPERGPT_DATA_DIR || paths.dataDir;
+  const modelsDir = process.env.PREPPERGPT_MODELS_DIR || `${dataDir}/models`;
+  const adminPassword = process.env.PREPPERGPT_ADMIN_PASSWORD || secret(18);
+  const jupyterToken = process.env.JUPYTER_TOKEN || secret(18);
+  const searxngSecret = process.env.SEARXNG_SECRET_KEY || secret(24);
+  const lines = {
+    PREPPERGPT_PROFILE: plan.profile,
+    PREPPERGPT_DATA_DIR: dataDir,
+    PREPPERGPT_MODELS_DIR: modelsDir,
+    PREPPERGPT_PORT: process.env.PREPPERGPT_PORT || "8080",
+    PREPPERGPT_DEFAULT_MODEL: plan.defaultModel,
+    PREPPERGPT_MODEL_ORDER_LIST: JSON.stringify(plan.routeIds),
+    PREPPERGPT_DOCKER_GPUS: detection.gpus?.length ? "all" : "",
+    WEBUI_NAME: "PrepperGPT",
+    WEBUI_ADMIN_EMAIL: process.env.WEBUI_ADMIN_EMAIL || "admin@preppergpt.local",
+    WEBUI_ADMIN_PASSWORD: adminPassword,
+    WEBUI_ADMIN_NAME: process.env.WEBUI_ADMIN_NAME || "PrepperGPT Admin",
+    WEBUI_SECRET_KEY: process.env.WEBUI_SECRET_KEY || secret(24),
+    JUPYTER_TOKEN: jupyterToken,
+    SEARXNG_SECRET_KEY: searxngSecret,
+    GLM52_BASE_URL: process.env.GLM52_BASE_URL || "http://127.0.0.1:11441/v1",
+    SLOCODE_BASE_URL: process.env.SLOCODE_BASE_URL || "http://127.0.0.1:11438/v1",
+    OLLAMA_BASE_URL: process.env.OLLAMA_BASE_URL || "http://127.0.0.1:11434"
+  };
+  return `${Object.entries(lines)
+    .map(([key, value]) => `${key}=${envQuote(value)}`)
+    .join("\n")}\n`;
+}
+
+function generatedCompose(plan, detection) {
+  const modelOrder = JSON.stringify(plan.routeIds);
+  const gpuBlock = detection.gpus?.length
+    ? [
+        "  ollama:",
+        "    gpus: all",
+        "  local-vision:",
+        "    gpus: all"
+      ]
+    : [];
+  return [
+    "services:",
+    "  open-webui:",
+    "    environment:",
+    `      DEFAULT_MODELS: "${plan.defaultModel}"`,
+    `      MODEL_ORDER_LIST: '${modelOrder.replaceAll("'", "''")}'`,
+    `      TASK_MODEL: "${plan.selected.fast?.id || plan.defaultModel}"`,
+    ...gpuBlock
+  ].join("\n") + "\n";
+}
+
+export function renderInstall(plan, detection, options = {}) {
+  const paths = runtimePaths(options.home);
+  fs.mkdirSync(paths.root, { recursive: true });
+  fs.mkdirSync(paths.dataDir, { recursive: true });
+  fs.mkdirSync(paths.composeDir, { recursive: true });
+  fs.mkdirSync(`${paths.dataDir}/preppergpt`, { recursive: true });
+  fs.mkdirSync(`${paths.dataDir}/models`, { recursive: true });
+  writeText(paths.envFile, envFile(plan, paths, detection), 0o600);
+  writeText(paths.generatedCompose, generatedCompose(plan, detection));
+  writeJson(paths.modelPlan, plan);
+  writeJson(paths.detectReport, detection);
+  return {
+    ...paths,
+    packageCompose: packagedPath("compose", "preppergpt.yaml")
+  };
+}

package/installer/lib/util.mjs

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+
+export function commandResult(command, args = [], options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: options.timeoutMs || 15000,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error
+  };
+}
+
+export function commandExists(command) {
+  return commandResult("sh", ["-lc", `command -v ${shellQuote(command)}`], { timeoutMs: 3000 }).ok;
+}
+
+export function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+export function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function writeText(file, value, mode) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, value);
+  if (mode) {
+    fs.chmodSync(file, mode);
+  }
+}
+
+export function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+export function envQuote(value) {
+  const text = String(value ?? "");
+  if (/^[A-Za-z0-9_./:@,+-]*$/.test(text)) {
+    return text;
+  }
+  return JSON.stringify(text);
+}
+
+export function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const [rawKey, inlineValue] = arg.slice(2).split(/=(.*)/s, 2);
+    const key = rawKey.replaceAll("-", "_");
+    if (inlineValue !== undefined) {
+      flags[key] = inlineValue;
+    } else if (argv[index + 1] && !argv[index + 1].startsWith("--")) {
+      flags[key] = argv[index + 1];
+      index += 1;
+    } else {
+      flags[key] = true;
+    }
+  }
+  return { flags, positional };
+}
+
+export function gb(bytes) {
+  return Math.round((bytes / 1024 ** 3) * 10) / 10;
+}
+
+export function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "preppergpt",
+  "version": "0.1.0",
+  "description": "A local-first ChatGPT-like field kit built on OpenWebUI and local models.",
+  "type": "module",
+  "bin": {
+    "preppergpt": "bin/preppergpt.js"
+  },
+  "files": [
+    "bin/",
+    "installer/",
+    "compose/",
+    "profiles/",
+    "themes/",
+    "services/",
+    "docs/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "check": "npm run test && node bin/preppergpt.js plan --profile balanced --json >/dev/null && node bin/preppergpt.js install --profile balanced --dry-run",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "keywords": [
+    "openwebui",
+    "local-ai",
+    "llm",
+    "ollama",
+    "preppergpt",
+    "offline-ai"
+  ],
+  "homepage": "https://github.com/teamslop/preppergpt#readme",
+  "bugs": {
+    "url": "https://github.com/teamslop/preppergpt/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/teamslop/preppergpt.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}