@revealui/setup 0.3.4 → 0.3.6

package/dist/index.js

@@ -1,3 +1,148 @@
+// src/bootstrap/index.ts
+function richTextDoc(...nodes) {
+  return {
+    root: {
+      type: "root",
+      children: nodes,
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    }
+  };
+}
+function heading(text, tag = "h2") {
+  return {
+    type: "heading",
+    children: [{ type: "text", detail: 0, format: 0, mode: "normal", style: "", text, version: 1 }],
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    tag,
+    version: 1
+  };
+}
+function paragraph(text) {
+  return {
+    type: "paragraph",
+    children: [{ type: "text", detail: 0, format: 0, mode: "normal", style: "", text, version: 1 }],
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    textFormat: 0,
+    textStyle: "",
+    version: 1
+  };
+}
+var SEED_PAGES = [
+  {
+    title: "Home",
+    slug: "home",
+    path: "/",
+    layout: [
+      {
+        blockType: "content",
+        columns: [
+          {
+            size: "full",
+            richText: richTextDoc(
+              heading("Welcome to RevealUI"),
+              paragraph(
+                "Your agentic business runtime is ready. Visit /admin to manage content, configure collections, and build your application."
+              )
+            )
+          }
+        ]
+      }
+    ]
+  }
+];
+async function bootstrap(options) {
+  const { revealui, admin, seed = true } = options;
+  try {
+    const existing = await revealui.find({
+      collection: "users",
+      limit: 1,
+      depth: 0
+    });
+    if (existing.totalDocs > 0) {
+      return {
+        status: "locked",
+        message: "Setup already completed. Users exist."
+      };
+    }
+  } catch (err) {
+    return {
+      status: "error",
+      message: "Database connection failed. Check POSTGRES_URL or DATABASE_URL.",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  if (!(admin.email && admin.password)) {
+    return {
+      status: "error",
+      message: "Admin email and password are required."
+    };
+  }
+  if (admin.password.length < 12) {
+    return {
+      status: "error",
+      message: "Admin password must be at least 12 characters."
+    };
+  }
+  try {
+    await revealui.create({
+      collection: "users",
+      data: {
+        name: admin.name ?? "Admin",
+        email: admin.email,
+        password: admin.password,
+        role: "owner",
+        roles: ["super-admin"]
+      }
+    });
+  } catch (err) {
+    const pgCode = err.code;
+    if (pgCode === "23505") {
+      return {
+        status: "error",
+        message: "A user with that email already exists."
+      };
+    }
+    return {
+      status: "error",
+      message: "Failed to create admin user.",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  let seeded = false;
+  if (seed) {
+    try {
+      for (const page of SEED_PAGES) {
+        const existing = await revealui.find({
+          collection: "pages",
+          where: { slug: { equals: page.slug } },
+          limit: 1
+        });
+        if (existing.docs.length === 0) {
+          await revealui.create({
+            collection: "pages",
+            data: page
+          });
+        }
+      }
+      seeded = true;
+    } catch {
+    }
+  }
+  return {
+    status: "created",
+    message: `Admin user created${seeded ? " and content seeded" : ""}. Sign in at /admin.`,
+    user: { email: admin.email, role: "owner" },
+    seeded
+  };
+}
+
 // src/environment/generators.ts
 import { randomBytes } from "crypto";
 function generateSecret(length = 32) {
@@ -5,10 +150,15 @@ function generateSecret(length = 32) {
 }
 function generatePassword(length = 16) {
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
+  const maxValid = 256 - 256 % chars.length;
   let password = "";
-  const randomValues = randomBytes(length);
-  for (let i = 0; i < length; i++) {
-    password += chars[randomValues[i] % chars.length];
+  while (password.length < length) {
+    const buf = randomBytes(length - password.length + 16);
+    for (let i = 0; i < buf.length && password.length < length; i++) {
+      if (buf[i] < maxValid) {
+        password += chars[buf[i] % chars.length];
+      }
+    }
   }
   return password;
 }
@@ -456,18 +606,370 @@ 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,
   validateEnv,
   validators
 };
-//# sourceMappingURL=index.js.map

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 };