@revealui/setup 0.3.5 → 0.3.6

package/dist/bootstrap/index.js

@@ -97,8 +97,8 @@ async function bootstrap(options) {
         name: admin.name ?? "Admin",
         email: admin.email,
         password: admin.password,
-        role: "user-super-admin",
-        roles: ["user-super-admin"]
+        role: "owner",
+        roles: ["super-admin"]
       }
     });
   } catch (err) {
@@ -138,7 +138,7 @@ async function bootstrap(options) {
   return {
     status: "created",
     message: `Admin user created${seeded ? " and content seeded" : ""}. Sign in at /admin.`,
-    user: { email: admin.email, role: "user-super-admin" },
+    user: { email: admin.email, role: "owner" },
     seeded
   };
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { BootstrapAdminConfig, BootstrapOptions, BootstrapResult, RevealUILike, bootstrap } from './bootstrap/index.js';
 export { SetupEnvironmentOptions, SetupEnvironmentResult, generatePassword, generateSecret, parseEnvContent, setupEnvironment, updateEnvValue } from './environment/index.js';
+export { PROFILES, PlanAction, PlatformClass, SystemInfo, TunePlan, TuneProfile, TuneValues, WslConfigTune, detectSystem, generateAutoplan, generatePlan, matchProfile } from './system-tune/index.js';
 export { LogLevel, Logger, LoggerOptions, createLogger, handleASTParseError, logger } from './utils/index.js';
 export { EnvVariable, OPTIONAL_ENV_VARS, REQUIRED_ENV_VARS, ValidationResult, validateEnv, validators } from './validators/index.js';

package/dist/index.js

@@ -97,8 +97,8 @@ async function bootstrap(options) {
         name: admin.name ?? "Admin",
         email: admin.email,
         password: admin.password,
-        role: "user-super-admin",
-        roles: ["user-super-admin"]
+        role: "owner",
+        roles: ["super-admin"]
       }
     });
   } catch (err) {
@@ -138,7 +138,7 @@ async function bootstrap(options) {
   return {
     status: "created",
     message: `Admin user created${seeded ? " and content seeded" : ""}. Sign in at /admin.`,
-    user: { email: admin.email, role: "user-super-admin" },
+    user: { email: admin.email, role: "owner" },
     seeded
   };
 }
@@ -606,15 +606,367 @@ async function generateSecrets(envPath, logger2) {
   await writeFile(envPath, content);
   logger2.success("Generated REVEALUI_SECRET");
 }
+
+// src/system-tune/detect.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { arch, cpus, freemem, homedir, platform, release, totalmem } from "os";
+import { join as join2 } from "path";
+function detectPlatformClass() {
+  const p = platform();
+  if (p === "linux") {
+    try {
+      const procVersion = readFileSync("/proc/version", "utf8").toLowerCase();
+      if (procVersion.includes("microsoft") || procVersion.includes("wsl")) {
+        return "wsl2";
+      }
+    } catch {
+    }
+    try {
+      if (existsSync("/.dockerenv")) return "docker";
+      const cgroup = readFileSync("/proc/1/cgroup", "utf8");
+      if (cgroup.includes("docker") || cgroup.includes("containerd")) return "docker";
+    } catch {
+    }
+    try {
+      const dmiProduct = readFileSync("/sys/class/dmi/id/product_name", "utf8").trim().toLowerCase();
+      if (dmiProduct.includes("virtual") || dmiProduct.includes("kvm") || dmiProduct.includes("xen") || dmiProduct.includes("hvm")) {
+        return "cloud-vm";
+      }
+    } catch {
+    }
+    return "linux";
+  }
+  if (p === "darwin") return "macos";
+  if (p === "win32") return "windows";
+  return "unknown";
+}
+function detectDistro() {
+  try {
+    const osRelease = readFileSync("/etc/os-release", "utf8");
+    const match = osRelease.match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
+function detectMemory() {
+  const p = platform();
+  if (p === "linux") {
+    try {
+      const meminfo = readFileSync("/proc/meminfo", "utf8");
+      const parse = (key) => {
+        const match = meminfo.match(new RegExp(`^${key}:\\s+(\\d+)`, "m"));
+        return match ? Number.parseInt(match[1], 10) * 1024 : 0;
+      };
+      return {
+        totalBytes: parse("MemTotal"),
+        freeBytes: parse("MemAvailable") || parse("MemFree"),
+        swapTotalBytes: parse("SwapTotal"),
+        swapFreeBytes: parse("SwapFree")
+      };
+    } catch {
+    }
+  }
+  return {
+    totalBytes: totalmem(),
+    freeBytes: freemem(),
+    swapTotalBytes: 0,
+    swapFreeBytes: 0
+  };
+}
+function detectCpu() {
+  const cores = cpus();
+  const model = cores[0]?.model ?? "unknown";
+  const logicalCores = cores.length;
+  let physicalCores = logicalCores;
+  const p = platform();
+  if (p === "linux") {
+    try {
+      const output = execSync('grep "^cpu cores" /proc/cpuinfo | head -1', {
+        encoding: "utf8",
+        timeout: 2e3
+      });
+      const match = output.match(/:\s*(\d+)/);
+      if (match) physicalCores = Number.parseInt(match[1], 10);
+    } catch {
+    }
+  } else if (p === "darwin") {
+    try {
+      const output = execSync("sysctl -n hw.physicalcpu", { encoding: "utf8", timeout: 2e3 });
+      physicalCores = Number.parseInt(output.trim(), 10) || logicalCores;
+    } catch {
+    }
+  }
+  return { model, physicalCores, logicalCores };
+}
+function detectDisk() {
+  const p = platform();
+  const target = process.cwd();
+  if (p === "linux" || p === "darwin") {
+    try {
+      const output = execSync(`df -B1 "${target}" | tail -1`, { encoding: "utf8", timeout: 2e3 });
+      const parts = output.trim().split(/\s+/);
+      if (parts.length >= 4) {
+        return {
+          totalBytes: Number.parseInt(parts[1], 10) || 0,
+          freeBytes: Number.parseInt(parts[3], 10) || 0
+        };
+      }
+    } catch {
+    }
+  }
+  return { totalBytes: 0, freeBytes: 0 };
+}
+function detectExistingConfigs() {
+  const home = homedir();
+  let wslconfig = false;
+  try {
+    const windowsUser = execSync('cmd.exe /c "echo %USERPROFILE%" 2>/dev/null', {
+      encoding: "utf8",
+      timeout: 3e3
+    }).trim();
+    const wslPath = windowsUser.replace(/\\/g, "/").replace(/^([A-Z]):/i, (_, d) => `/mnt/${d.toLowerCase()}`);
+    wslconfig = existsSync(join2(wslPath, ".wslconfig"));
+  } catch {
+    wslconfig = existsSync(join2(home, ".wslconfig"));
+  }
+  let earlyoom = false;
+  try {
+    const result = execSync("systemctl is-enabled earlyoom 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    earlyoom = result.trim() === "enabled";
+  } catch {
+    earlyoom = false;
+  }
+  let dockerAutostart = false;
+  try {
+    const result = execSync("systemctl is-enabled docker 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    dockerAutostart = result.trim() === "enabled";
+  } catch {
+    dockerAutostart = false;
+  }
+  const nodeOptions = process.env.NODE_OPTIONS ?? null;
+  return { wslconfig, earlyoom, dockerAutostart, nodeOptions };
+}
+function detectSystem() {
+  return {
+    os: {
+      platform: platform(),
+      release: release(),
+      arch: arch(),
+      distro: detectDistro()
+    },
+    platformClass: detectPlatformClass(),
+    memory: detectMemory(),
+    cpu: detectCpu(),
+    disk: detectDisk(),
+    existingConfigs: detectExistingConfigs()
+  };
+}
+
+// src/system-tune/profiles/wsl-low-ram.json
+var wsl_low_ram_default = {
+  $schema: "../profile-schema.json",
+  id: "wsl-low-ram",
+  name: "WSL2 Low-RAM Host",
+  description: "Safe defaults for WSL2 on hosts with \u22648 GB RAM. Prevents the VM from starving Windows by capping memory, disabling aggressive reclaim, and keeping Docker off by default.",
+  version: "0.1.0",
+  origin: "2026-04-13 crash postmortem: WSL on 7.3 GB host claimed ~6 GB, starving Windows. Hand-authored fix captured as seed profile.",
+  match: {
+    platform: "wsl2",
+    maxHostRamGb: 8
+  },
+  tune: {
+    wslconfig: {
+      memory: "4GB",
+      processors: 2,
+      swap: "2GB",
+      vmIdleTimeout: -1,
+      autoMemoryReclaim: "disabled",
+      networkingMode: "mirrored"
+    },
+    node: {
+      maxOldSpaceSize: 2048
+    },
+    pnpm: {
+      childConcurrency: 2
+    },
+    turbo: {
+      concurrency: 2
+    },
+    vitest: {
+      maxThreads: 2
+    },
+    earlyoom: {
+      enabled: true,
+      memThreshold: 5,
+      swapThreshold: 10,
+      prefer: "turbo|biome|vitest|tsc|esbuild"
+    },
+    docker: {
+      autostart: false
+    }
+  }
+};
+
+// src/system-tune/profiles.ts
+var PROFILES = [wsl_low_ram_default];
+
+// src/system-tune/plan.ts
+function matchProfile(system) {
+  const ramGb = system.memory.totalBytes / (1024 * 1024 * 1024);
+  for (const profile of PROFILES) {
+    if (profile.match.platform !== system.platformClass) continue;
+    if (profile.match.maxHostRamGb !== void 0 && ramGb > profile.match.maxHostRamGb) continue;
+    if (profile.match.minHostRamGb !== void 0 && ramGb < profile.match.minHostRamGb) continue;
+    return profile;
+  }
+  return null;
+}
+function generateWslActions(profile, system) {
+  const actions = [];
+  const wsl = profile.tune.wslconfig;
+  if (!wsl) return actions;
+  const entries = [];
+  if (wsl.memory) entries.push(["memory", wsl.memory]);
+  if (wsl.processors !== void 0) entries.push(["processors", String(wsl.processors)]);
+  if (wsl.swap) entries.push(["swap", wsl.swap]);
+  if (wsl.vmIdleTimeout !== void 0) entries.push(["vmIdleTimeout", String(wsl.vmIdleTimeout)]);
+  if (wsl.autoMemoryReclaim) entries.push(["autoMemoryReclaim", wsl.autoMemoryReclaim]);
+  if (wsl.networkingMode) entries.push(["networkingMode", wsl.networkingMode]);
+  if (entries.length > 0) {
+    const desired = entries.map(([k, v]) => `${k}=${v}`).join(", ");
+    actions.push({
+      target: ".wslconfig [wsl2]",
+      current: system.existingConfigs.wslconfig ? "(exists, values unknown)" : null,
+      desired,
+      privileged: false,
+      description: `Set WSL2 config: ${desired}`
+    });
+  }
+  return actions;
+}
+function generateNodeActions(profile, system) {
+  const actions = [];
+  const node = profile.tune.node;
+  if (!node?.maxOldSpaceSize) return actions;
+  const desired = `--max-old-space-size=${node.maxOldSpaceSize}`;
+  const current = system.existingConfigs.nodeOptions;
+  const alreadySet = current?.includes("max-old-space-size") ?? false;
+  if (!alreadySet) {
+    actions.push({
+      target: "NODE_OPTIONS",
+      current,
+      desired: current ? `${current} ${desired}` : desired,
+      privileged: false,
+      description: `Add ${desired} to NODE_OPTIONS in shell profile`
+    });
+  }
+  return actions;
+}
+function generateEarlyoomActions(profile, system) {
+  const actions = [];
+  const oom = profile.tune.earlyoom;
+  if (!oom?.enabled) return actions;
+  if (!system.existingConfigs.earlyoom) {
+    const args = [`-m ${oom.memThreshold ?? 5}`, `-s ${oom.swapThreshold ?? 10}`];
+    if (oom.prefer) args.push(`--prefer '${oom.prefer}'`);
+    actions.push({
+      target: "/etc/default/earlyoom",
+      current: null,
+      desired: `EARLYOOM_ARGS="${args.join(" ")}"`,
+      privileged: true,
+      description: `Install and configure earlyoom (kill memory hogs before OOM killer)`
+    });
+  }
+  return actions;
+}
+function generateDockerActions(profile, system) {
+  const actions = [];
+  const docker = profile.tune.docker;
+  if (docker === void 0) return actions;
+  if (!docker.autostart && system.existingConfigs.dockerAutostart) {
+    actions.push({
+      target: "systemctl docker",
+      current: "enabled (autostart)",
+      desired: "disabled (on-demand via sudo systemctl start docker)",
+      privileged: true,
+      description: "Disable Docker autostart to save ~200-400 MB RAM on boot"
+    });
+  }
+  return actions;
+}
+function generateConcurrencyActions(profile) {
+  const actions = [];
+  if (profile.tune.pnpm?.childConcurrency) {
+    actions.push({
+      target: ".npmrc or pnpm config",
+      current: null,
+      desired: `child-concurrency=${profile.tune.pnpm.childConcurrency}`,
+      privileged: false,
+      description: `Limit pnpm child concurrency to ${profile.tune.pnpm.childConcurrency}`
+    });
+  }
+  if (profile.tune.turbo?.concurrency) {
+    actions.push({
+      target: "turbo.json or TURBO_CONCURRENCY",
+      current: null,
+      desired: `concurrency=${profile.tune.turbo.concurrency}`,
+      privileged: false,
+      description: `Limit Turbo concurrency to ${profile.tune.turbo.concurrency}`
+    });
+  }
+  if (profile.tune.vitest?.maxThreads) {
+    actions.push({
+      target: "vitest.config poolOptions.threads.maxThreads",
+      current: null,
+      desired: `maxThreads=${profile.tune.vitest.maxThreads}`,
+      privileged: false,
+      description: `Limit Vitest threads to ${profile.tune.vitest.maxThreads}`
+    });
+  }
+  return actions;
+}
+function generatePlan(system, profile) {
+  const actions = [
+    ...generateWslActions(profile, system),
+    ...generateNodeActions(profile, system),
+    ...generateEarlyoomActions(profile, system),
+    ...generateDockerActions(profile, system),
+    ...generateConcurrencyActions(profile)
+  ];
+  return {
+    profileId: profile.id,
+    system,
+    actions,
+    isNoop: actions.length === 0
+  };
+}
+function generateAutoplan(system) {
+  const profile = matchProfile(system);
+  if (!profile) return null;
+  return generatePlan(system, profile);
+}
 export {
   OPTIONAL_ENV_VARS,
+  PROFILES,
   REQUIRED_ENV_VARS,
   bootstrap,
   createLogger,
+  detectSystem,
+  generateAutoplan,
   generatePassword,
+  generatePlan,
   generateSecret,
   handleASTParseError,
   logger,
+  matchProfile,
   parseEnvContent,
   setupEnvironment,
   updateEnvValue,

package/dist/system-tune/index.d.ts

@@ -0,0 +1,152 @@
+/**
+ * System Tune Types
+ *
+ * Shared types for hardware detection, tuning profiles, and plan generation.
+ */
+type PlatformClass = 'wsl2' | 'linux' | 'macos' | 'windows' | 'docker' | 'cloud-vm' | 'unknown';
+interface SystemInfo {
+    /** OS/distro/kernel identification */
+    os: {
+        platform: NodeJS.Platform;
+        release: string;
+        arch: string;
+        distro?: string;
+    };
+    /** Detected platform class */
+    platformClass: PlatformClass;
+    /** Memory in bytes */
+    memory: {
+        totalBytes: number;
+        freeBytes: number;
+        swapTotalBytes: number;
+        swapFreeBytes: number;
+    };
+    /** CPU info */
+    cpu: {
+        model: string;
+        physicalCores: number;
+        logicalCores: number;
+    };
+    /** Disk info for the working directory */
+    disk: {
+        totalBytes: number;
+        freeBytes: number;
+    };
+    /** Existing configs already present */
+    existingConfigs: {
+        wslconfig: boolean;
+        earlyoom: boolean;
+        dockerAutostart: boolean;
+        nodeOptions: string | null;
+    };
+}
+interface WslConfigTune {
+    memory?: string;
+    processors?: number;
+    swap?: string;
+    vmIdleTimeout?: number;
+    autoMemoryReclaim?: string;
+    networkingMode?: string;
+}
+interface TuneValues {
+    wslconfig?: WslConfigTune;
+    node?: {
+        maxOldSpaceSize?: number;
+    };
+    pnpm?: {
+        childConcurrency?: number;
+    };
+    turbo?: {
+        concurrency?: number;
+    };
+    vitest?: {
+        maxThreads?: number;
+    };
+    earlyoom?: {
+        enabled?: boolean;
+        memThreshold?: number;
+        swapThreshold?: number;
+        prefer?: string;
+    };
+    docker?: {
+        autostart?: boolean;
+    };
+    macos?: {
+        maxFiles?: number;
+        spotlightExclusions?: string[];
+    };
+    windows?: {
+        defenderExclusions?: string[];
+        longPaths?: boolean;
+    };
+}
+interface TuneProfile {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    origin?: string;
+    match: {
+        platform: PlatformClass;
+        maxHostRamGb?: number;
+        minHostRamGb?: number;
+    };
+    tune: TuneValues;
+}
+interface PlanAction {
+    /** What file or setting is being changed */
+    target: string;
+    /** What the current value is (null if not set) */
+    current: string | null;
+    /** What the new value will be */
+    desired: string;
+    /** Whether this requires elevated privileges */
+    privileged: boolean;
+    /** Human-readable description */
+    description: string;
+}
+interface TunePlan {
+    /** Profile that generated this plan */
+    profileId: string;
+    /** Detected system info */
+    system: SystemInfo;
+    /** Actions to take */
+    actions: PlanAction[];
+    /** Whether all actions are no-ops (system already tuned) */
+    isNoop: boolean;
+}
+
+/**
+ * System Detection Layer
+ *
+ * Scans the host's hardware and platform to produce a SystemInfo snapshot.
+ * This is the "read" side — no mutations, only observation.
+ */
+
+/** Scan the current host and return a SystemInfo snapshot. */
+declare function detectSystem(): SystemInfo;
+
+/**
+ * Plan Generator
+ *
+ * Pure function: (detected system state, profile) → plan of actions.
+ * No I/O — only computes the diff between current and desired state.
+ */
+
+/** Find the best matching profile for the detected system. */
+declare function matchProfile(system: SystemInfo): TuneProfile | null;
+/** Generate a tuning plan from detected system state and a profile. */
+declare function generatePlan(system: SystemInfo, profile: TuneProfile): TunePlan;
+/** Detect system, find matching profile, and generate plan. */
+declare function generateAutoplan(system: SystemInfo): TunePlan | null;
+
+/**
+ * Built-in Tuning Profiles
+ *
+ * Profiles are ordered by specificity — the first match wins.
+ * Add new profiles here, most specific first.
+ */
+
+declare const PROFILES: TuneProfile[];
+
+export { PROFILES, type PlanAction, type PlatformClass, type SystemInfo, type TunePlan, type TuneProfile, type TuneValues, type WslConfigTune, detectSystem, generateAutoplan, generatePlan, matchProfile };

package/dist/system-tune/index.js

@@ -0,0 +1,353 @@
+// src/system-tune/detect.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { arch, cpus, freemem, homedir, platform, release, totalmem } from "os";
+import { join } from "path";
+function detectPlatformClass() {
+  const p = platform();
+  if (p === "linux") {
+    try {
+      const procVersion = readFileSync("/proc/version", "utf8").toLowerCase();
+      if (procVersion.includes("microsoft") || procVersion.includes("wsl")) {
+        return "wsl2";
+      }
+    } catch {
+    }
+    try {
+      if (existsSync("/.dockerenv")) return "docker";
+      const cgroup = readFileSync("/proc/1/cgroup", "utf8");
+      if (cgroup.includes("docker") || cgroup.includes("containerd")) return "docker";
+    } catch {
+    }
+    try {
+      const dmiProduct = readFileSync("/sys/class/dmi/id/product_name", "utf8").trim().toLowerCase();
+      if (dmiProduct.includes("virtual") || dmiProduct.includes("kvm") || dmiProduct.includes("xen") || dmiProduct.includes("hvm")) {
+        return "cloud-vm";
+      }
+    } catch {
+    }
+    return "linux";
+  }
+  if (p === "darwin") return "macos";
+  if (p === "win32") return "windows";
+  return "unknown";
+}
+function detectDistro() {
+  try {
+    const osRelease = readFileSync("/etc/os-release", "utf8");
+    const match = osRelease.match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
+function detectMemory() {
+  const p = platform();
+  if (p === "linux") {
+    try {
+      const meminfo = readFileSync("/proc/meminfo", "utf8");
+      const parse = (key) => {
+        const match = meminfo.match(new RegExp(`^${key}:\\s+(\\d+)`, "m"));
+        return match ? Number.parseInt(match[1], 10) * 1024 : 0;
+      };
+      return {
+        totalBytes: parse("MemTotal"),
+        freeBytes: parse("MemAvailable") || parse("MemFree"),
+        swapTotalBytes: parse("SwapTotal"),
+        swapFreeBytes: parse("SwapFree")
+      };
+    } catch {
+    }
+  }
+  return {
+    totalBytes: totalmem(),
+    freeBytes: freemem(),
+    swapTotalBytes: 0,
+    swapFreeBytes: 0
+  };
+}
+function detectCpu() {
+  const cores = cpus();
+  const model = cores[0]?.model ?? "unknown";
+  const logicalCores = cores.length;
+  let physicalCores = logicalCores;
+  const p = platform();
+  if (p === "linux") {
+    try {
+      const output = execSync('grep "^cpu cores" /proc/cpuinfo | head -1', {
+        encoding: "utf8",
+        timeout: 2e3
+      });
+      const match = output.match(/:\s*(\d+)/);
+      if (match) physicalCores = Number.parseInt(match[1], 10);
+    } catch {
+    }
+  } else if (p === "darwin") {
+    try {
+      const output = execSync("sysctl -n hw.physicalcpu", { encoding: "utf8", timeout: 2e3 });
+      physicalCores = Number.parseInt(output.trim(), 10) || logicalCores;
+    } catch {
+    }
+  }
+  return { model, physicalCores, logicalCores };
+}
+function detectDisk() {
+  const p = platform();
+  const target = process.cwd();
+  if (p === "linux" || p === "darwin") {
+    try {
+      const output = execSync(`df -B1 "${target}" | tail -1`, { encoding: "utf8", timeout: 2e3 });
+      const parts = output.trim().split(/\s+/);
+      if (parts.length >= 4) {
+        return {
+          totalBytes: Number.parseInt(parts[1], 10) || 0,
+          freeBytes: Number.parseInt(parts[3], 10) || 0
+        };
+      }
+    } catch {
+    }
+  }
+  return { totalBytes: 0, freeBytes: 0 };
+}
+function detectExistingConfigs() {
+  const home = homedir();
+  let wslconfig = false;
+  try {
+    const windowsUser = execSync('cmd.exe /c "echo %USERPROFILE%" 2>/dev/null', {
+      encoding: "utf8",
+      timeout: 3e3
+    }).trim();
+    const wslPath = windowsUser.replace(/\\/g, "/").replace(/^([A-Z]):/i, (_, d) => `/mnt/${d.toLowerCase()}`);
+    wslconfig = existsSync(join(wslPath, ".wslconfig"));
+  } catch {
+    wslconfig = existsSync(join(home, ".wslconfig"));
+  }
+  let earlyoom = false;
+  try {
+    const result = execSync("systemctl is-enabled earlyoom 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    earlyoom = result.trim() === "enabled";
+  } catch {
+    earlyoom = false;
+  }
+  let dockerAutostart = false;
+  try {
+    const result = execSync("systemctl is-enabled docker 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 2e3
+    });
+    dockerAutostart = result.trim() === "enabled";
+  } catch {
+    dockerAutostart = false;
+  }
+  const nodeOptions = process.env.NODE_OPTIONS ?? null;
+  return { wslconfig, earlyoom, dockerAutostart, nodeOptions };
+}
+function detectSystem() {
+  return {
+    os: {
+      platform: platform(),
+      release: release(),
+      arch: arch(),
+      distro: detectDistro()
+    },
+    platformClass: detectPlatformClass(),
+    memory: detectMemory(),
+    cpu: detectCpu(),
+    disk: detectDisk(),
+    existingConfigs: detectExistingConfigs()
+  };
+}
+
+// src/system-tune/profiles/wsl-low-ram.json
+var wsl_low_ram_default = {
+  $schema: "../profile-schema.json",
+  id: "wsl-low-ram",
+  name: "WSL2 Low-RAM Host",
+  description: "Safe defaults for WSL2 on hosts with \u22648 GB RAM. Prevents the VM from starving Windows by capping memory, disabling aggressive reclaim, and keeping Docker off by default.",
+  version: "0.1.0",
+  origin: "2026-04-13 crash postmortem: WSL on 7.3 GB host claimed ~6 GB, starving Windows. Hand-authored fix captured as seed profile.",
+  match: {
+    platform: "wsl2",
+    maxHostRamGb: 8
+  },
+  tune: {
+    wslconfig: {
+      memory: "4GB",
+      processors: 2,
+      swap: "2GB",
+      vmIdleTimeout: -1,
+      autoMemoryReclaim: "disabled",
+      networkingMode: "mirrored"
+    },
+    node: {
+      maxOldSpaceSize: 2048
+    },
+    pnpm: {
+      childConcurrency: 2
+    },
+    turbo: {
+      concurrency: 2
+    },
+    vitest: {
+      maxThreads: 2
+    },
+    earlyoom: {
+      enabled: true,
+      memThreshold: 5,
+      swapThreshold: 10,
+      prefer: "turbo|biome|vitest|tsc|esbuild"
+    },
+    docker: {
+      autostart: false
+    }
+  }
+};
+
+// src/system-tune/profiles.ts
+var PROFILES = [wsl_low_ram_default];
+
+// src/system-tune/plan.ts
+function matchProfile(system) {
+  const ramGb = system.memory.totalBytes / (1024 * 1024 * 1024);
+  for (const profile of PROFILES) {
+    if (profile.match.platform !== system.platformClass) continue;
+    if (profile.match.maxHostRamGb !== void 0 && ramGb > profile.match.maxHostRamGb) continue;
+    if (profile.match.minHostRamGb !== void 0 && ramGb < profile.match.minHostRamGb) continue;
+    return profile;
+  }
+  return null;
+}
+function generateWslActions(profile, system) {
+  const actions = [];
+  const wsl = profile.tune.wslconfig;
+  if (!wsl) return actions;
+  const entries = [];
+  if (wsl.memory) entries.push(["memory", wsl.memory]);
+  if (wsl.processors !== void 0) entries.push(["processors", String(wsl.processors)]);
+  if (wsl.swap) entries.push(["swap", wsl.swap]);
+  if (wsl.vmIdleTimeout !== void 0) entries.push(["vmIdleTimeout", String(wsl.vmIdleTimeout)]);
+  if (wsl.autoMemoryReclaim) entries.push(["autoMemoryReclaim", wsl.autoMemoryReclaim]);
+  if (wsl.networkingMode) entries.push(["networkingMode", wsl.networkingMode]);
+  if (entries.length > 0) {
+    const desired = entries.map(([k, v]) => `${k}=${v}`).join(", ");
+    actions.push({
+      target: ".wslconfig [wsl2]",
+      current: system.existingConfigs.wslconfig ? "(exists, values unknown)" : null,
+      desired,
+      privileged: false,
+      description: `Set WSL2 config: ${desired}`
+    });
+  }
+  return actions;
+}
+function generateNodeActions(profile, system) {
+  const actions = [];
+  const node = profile.tune.node;
+  if (!node?.maxOldSpaceSize) return actions;
+  const desired = `--max-old-space-size=${node.maxOldSpaceSize}`;
+  const current = system.existingConfigs.nodeOptions;
+  const alreadySet = current?.includes("max-old-space-size") ?? false;
+  if (!alreadySet) {
+    actions.push({
+      target: "NODE_OPTIONS",
+      current,
+      desired: current ? `${current} ${desired}` : desired,
+      privileged: false,
+      description: `Add ${desired} to NODE_OPTIONS in shell profile`
+    });
+  }
+  return actions;
+}
+function generateEarlyoomActions(profile, system) {
+  const actions = [];
+  const oom = profile.tune.earlyoom;
+  if (!oom?.enabled) return actions;
+  if (!system.existingConfigs.earlyoom) {
+    const args = [`-m ${oom.memThreshold ?? 5}`, `-s ${oom.swapThreshold ?? 10}`];
+    if (oom.prefer) args.push(`--prefer '${oom.prefer}'`);
+    actions.push({
+      target: "/etc/default/earlyoom",
+      current: null,
+      desired: `EARLYOOM_ARGS="${args.join(" ")}"`,
+      privileged: true,
+      description: `Install and configure earlyoom (kill memory hogs before OOM killer)`
+    });
+  }
+  return actions;
+}
+function generateDockerActions(profile, system) {
+  const actions = [];
+  const docker = profile.tune.docker;
+  if (docker === void 0) return actions;
+  if (!docker.autostart && system.existingConfigs.dockerAutostart) {
+    actions.push({
+      target: "systemctl docker",
+      current: "enabled (autostart)",
+      desired: "disabled (on-demand via sudo systemctl start docker)",
+      privileged: true,
+      description: "Disable Docker autostart to save ~200-400 MB RAM on boot"
+    });
+  }
+  return actions;
+}
+function generateConcurrencyActions(profile) {
+  const actions = [];
+  if (profile.tune.pnpm?.childConcurrency) {
+    actions.push({
+      target: ".npmrc or pnpm config",
+      current: null,
+      desired: `child-concurrency=${profile.tune.pnpm.childConcurrency}`,
+      privileged: false,
+      description: `Limit pnpm child concurrency to ${profile.tune.pnpm.childConcurrency}`
+    });
+  }
+  if (profile.tune.turbo?.concurrency) {
+    actions.push({
+      target: "turbo.json or TURBO_CONCURRENCY",
+      current: null,
+      desired: `concurrency=${profile.tune.turbo.concurrency}`,
+      privileged: false,
+      description: `Limit Turbo concurrency to ${profile.tune.turbo.concurrency}`
+    });
+  }
+  if (profile.tune.vitest?.maxThreads) {
+    actions.push({
+      target: "vitest.config poolOptions.threads.maxThreads",
+      current: null,
+      desired: `maxThreads=${profile.tune.vitest.maxThreads}`,
+      privileged: false,
+      description: `Limit Vitest threads to ${profile.tune.vitest.maxThreads}`
+    });
+  }
+  return actions;
+}
+function generatePlan(system, profile) {
+  const actions = [
+    ...generateWslActions(profile, system),
+    ...generateNodeActions(profile, system),
+    ...generateEarlyoomActions(profile, system),
+    ...generateDockerActions(profile, system),
+    ...generateConcurrencyActions(profile)
+  ];
+  return {
+    profileId: profile.id,
+    system,
+    actions,
+    isNoop: actions.length === 0
+  };
+}
+function generateAutoplan(system) {
+  const profile = matchProfile(system);
+  if (!profile) return null;
+  return generatePlan(system, profile);
+}
+export {
+  PROFILES,
+  detectSystem,
+  generateAutoplan,
+  generatePlan,
+  matchProfile
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revealui/setup",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Setup utilities for RevealUI projects - environment, database, and configuration management",
   "keywords": [
     "cli",
@@ -22,7 +22,7 @@
     "inquirer": "^13.4.1",
     "ora": "^9.3.0",
     "zod": "^4.3.6",
-    "@revealui/config": "0.3.4"
+    "@revealui/config": "0.4.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
@@ -54,6 +54,10 @@
     "./bootstrap": {
       "types": "./dist/bootstrap/index.d.ts",
       "import": "./dist/bootstrap/index.js"
+    },
+    "./system-tune": {
+      "types": "./dist/system-tune/index.d.ts",
+      "import": "./dist/system-tune/index.js"
     }
   },
   "files": [