boilercraft 1.0.0

package/services/engine/toolInstaller.js

@@ -0,0 +1,232 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+const axios = require('axios');
+
+/**
+ * Installs missing toolchains (PHP, Composer, .NET SDK) on demand.
+ *
+ * Where possible tools go into a per-user folder (~/.boilercraft/tools) with
+ * no admin rights needed; that folder is prepended to PATH for every command
+ * BoilerCraft runs, so freshly installed tools work immediately without
+ * restarting the terminal.
+ *
+ *   .NET SDK  → Microsoft's official dotnet-install script (exact major, user folder)
+ *   Composer  → official getcomposer.org installer, signature-verified (user folder)
+ *   PHP       → winget (Windows) / Homebrew (macOS) / apt · dnf · pacman (Linux)
+ */
+
+const TOOLS_HOME = process.env.BOILERCRAFT_TOOLS_HOME || path.join(os.homedir(), '.boilercraft', 'tools');
+const BIN_DIR = path.join(TOOLS_HOME, 'bin');
+const DOTNET_DIR = path.join(TOOLS_HOME, 'dotnet');
+const PHP_WINGET_ID = 'PHP.PHP.8.4';
+
+// Extra folders searched for tools, ahead of the system PATH.
+function toolPaths() {
+  const dirs = [BIN_DIR, DOTNET_DIR];
+  if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
+    // winget puts command shims here; a running process doesn't see PATH updates.
+    dirs.push(path.join(process.env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Links'));
+  }
+  return dirs.filter(d => fs.existsSync(d));
+}
+
+function toolEnv(base = process.env) {
+  const env = { ...base };
+  const key = Object.keys(env).find(k => k.toUpperCase() === 'PATH') || 'PATH';
+  const extra = toolPaths();
+  if (extra.length) env[key] = [...extra, env[key] || ''].join(path.delimiter);
+  if (fs.existsSync(path.join(DOTNET_DIR, process.platform === 'win32' ? 'dotnet.exe' : 'dotnet'))) {
+    env.DOTNET_ROOT = DOTNET_DIR;
+  }
+  return env;
+}
+
+function exec(cmd, args, { shell = false } = {}) {
+  return new Promise((resolve, reject) => {
+    // stdio inherit: installers may show progress or ask for a sudo password.
+    const child = spawn(cmd, args, { stdio: 'inherit', env: toolEnv(), shell });
+    child.on('error', reject);
+    child.on('close', code => (code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${code}`))));
+  });
+}
+
+function which(cmd) {
+  return new Promise(resolve => {
+    const probe = process.platform === 'win32' ? 'where' : 'which';
+    const child = spawn(probe, [cmd], { env: toolEnv(), shell: process.platform === 'win32' });
+    let out = '';
+    child.stdout.on('data', d => (out += d));
+    child.on('error', () => resolve(null));
+    child.on('close', code => resolve(code === 0 ? out.split(/\r?\n/)[0].trim() : null));
+  });
+}
+
+async function download(url, dest) {
+  const res = await axios.get(url, { responseType: 'arraybuffer', timeout: 60000 });
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, Buffer.from(res.data));
+  return dest;
+}
+
+// ---------------------------------------------------------------------------
+// Recipes
+// ---------------------------------------------------------------------------
+
+async function installDotnet({ major }, log) {
+  const channel = `${major || 'LTS'}${major ? '.0' : ''}`;
+  log(`Installing .NET SDK ${channel} into ${DOTNET_DIR} (official dotnet-install script)`);
+  if (process.platform === 'win32') {
+    const script = await download('https://dot.net/v1/dotnet-install.ps1', path.join(TOOLS_HOME, 'dotnet-install.ps1'));
+    await exec('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script, '-Channel', channel, '-InstallDir', DOTNET_DIR]);
+  } else {
+    const script = await download('https://dot.net/v1/dotnet-install.sh', path.join(TOOLS_HOME, 'dotnet-install.sh'));
+    await exec('bash', [script, '--channel', channel, '--install-dir', DOTNET_DIR]);
+  }
+}
+
+async function installComposer(opts, log) {
+  if (!(await which('php'))) throw new Error('Composer needs PHP — install PHP first.');
+  log(`Installing Composer into ${BIN_DIR} (official installer, signature-verified)`);
+  const installer = await download('https://getcomposer.org/installer', path.join(TOOLS_HOME, 'composer-setup.php'));
+  const expected = (await axios.get('https://composer.github.io/installer.sig', { timeout: 15000 })).data.trim();
+  const actual = crypto.createHash('sha384').update(fs.readFileSync(installer)).digest('hex');
+  if (actual !== expected) {
+    fs.rmSync(installer, { force: true });
+    throw new Error('Composer installer signature mismatch — aborted.');
+  }
+  fs.mkdirSync(BIN_DIR, { recursive: true });
+  await exec('php', [installer, `--install-dir=${BIN_DIR}`, '--filename=composer.phar'], { shell: process.platform === 'win32' });
+  fs.rmSync(installer, { force: true });
+
+  // Shim so plain `composer` works.
+  if (process.platform === 'win32') {
+    fs.writeFileSync(path.join(BIN_DIR, 'composer.bat'), '@php "%~dp0composer.phar" %*\r\n');
+  } else {
+    const shim = path.join(BIN_DIR, 'composer');
+    fs.writeFileSync(shim, '#!/bin/sh\nexec php "$(dirname "$0")/composer.phar" "$@"\n');
+    fs.chmodSync(shim, 0o755);
+  }
+}
+
+// The Windows PHP zip ships without php.ini, so openssl/mbstring/etc. are off
+// and Composer/Laravel fail. Create one from the bundled development template.
+function ensureWindowsPhpIni(phpExe, log) {
+  const dir = path.dirname(fs.realpathSync(phpExe));
+  const ini = path.join(dir, 'php.ini');
+  if (fs.existsSync(ini)) return;
+  const template = path.join(dir, 'php.ini-development');
+  if (!fs.existsSync(template)) return log(`php.ini template not found in ${dir}; enable extensions manually.`);
+  let content = fs.readFileSync(template, 'utf8');
+  content = content.replace(/^;\s*extension_dir\s*=\s*"ext"/m, 'extension_dir = "ext"');
+  for (const ext of ['curl', 'fileinfo', 'mbstring', 'openssl', 'pdo_mysql', 'pdo_sqlite', 'sqlite3', 'zip', 'intl', 'sodium']) {
+    content = content.replace(new RegExp(`^;\\s*extension=${ext}\\s*$`, 'm'), `extension=${ext}`);
+  }
+  fs.writeFileSync(ini, content);
+  log(`Created ${ini} with the extensions Laravel needs.`);
+}
+
+async function installPhp(opts, log) {
+  if (process.platform === 'win32') {
+    if (!(await which('winget'))) throw new Error('winget not found. Install PHP manually: https://windows.php.net/download');
+    log(`Installing PHP via winget (${PHP_WINGET_ID})`);
+    await exec('winget', ['install', '--id', PHP_WINGET_ID, '-e', '--accept-source-agreements', '--accept-package-agreements'], { shell: true });
+    const php = await which('php');
+    if (!php) throw new Error('PHP installed, but not found on PATH yet. Open a new terminal and run the command again.');
+    ensureWindowsPhpIni(php, log);
+  } else if (process.platform === 'darwin') {
+    if (!(await which('brew'))) throw new Error('Homebrew not found. Install it from https://brew.sh, then re-run.');
+    log('Installing PHP via Homebrew');
+    await exec('brew', ['install', 'php']);
+  } else {
+    const managers = [
+      ['apt-get', ['sudo', 'apt-get', 'install', '-y', 'php-cli', 'php-mbstring', 'php-xml', 'php-curl', 'php-zip', 'php-sqlite3', 'php-mysql', 'php-intl', 'unzip']],
+      ['dnf', ['sudo', 'dnf', 'install', '-y', 'php-cli', 'php-mbstring', 'php-xml', 'php-pdo', 'php-mysqlnd', 'php-intl', 'unzip']],
+      ['pacman', ['sudo', 'pacman', '-S', '--noconfirm', 'php', 'unzip']]
+    ];
+    for (const [probe, [cmd, ...args]] of managers) {
+      if (await which(probe)) {
+        log(`Installing PHP via ${probe} (you may be asked for your password)`);
+        return exec(cmd, args);
+      }
+    }
+    throw new Error('No supported package manager found. Install PHP 8.3+ manually.');
+  }
+}
+
+/**
+ * Makes tools installed into TOOLS_HOME available in new terminals too, by
+ * adding them to the *user* PATH (no admin): the user Path environment
+ * variable on Windows, the shell rc file elsewhere. Returns a description of
+ * what was changed, or null if nothing needed changing.
+ */
+async function persistPath() {
+  const dirs = [BIN_DIR, DOTNET_DIR].filter(d => fs.existsSync(d));
+  if (!dirs.length || process.env.BOILERCRAFT_NO_PATH_UPDATE) return null;
+  const hasDotnet = dirs.includes(DOTNET_DIR);
+
+  if (process.platform === 'win32') {
+    // Read-modify-write of the User scope only, so the (long) machine PATH is
+    // never copied into it and nothing gets truncated (unlike setx).
+    const ps = [
+      '$p = [Environment]::GetEnvironmentVariable("Path", "User"); if (-not $p) { $p = "" }',
+      `$add = @(${dirs.map(d => `"${d}"`).join(',')}) | Where-Object { ($p -split ";") -notcontains $_ }`,
+      'if ($add) { [Environment]::SetEnvironmentVariable("Path", (($add + ($p -split ";" | Where-Object { $_ })) -join ";"), "User"); Write-Output "changed" }',
+      hasDotnet ? `[Environment]::SetEnvironmentVariable("DOTNET_ROOT", "${DOTNET_DIR}", "User")` : ''
+    ].join('; ');
+    await new Promise((resolve, reject) => {
+      const child = spawn('powershell.exe', ['-NoProfile', '-Command', ps], { stdio: 'ignore' });
+      child.on('error', reject);
+      child.on('close', resolve);
+    });
+    return `Added ${dirs.join(', ')} to your user PATH. Open a new terminal to use them.`;
+  }
+
+  const shell = path.basename(process.env.SHELL || '');
+  const rc = path.join(os.homedir(), shell === 'zsh' ? '.zshrc' : shell === 'bash' ? '.bashrc' : '.profile');
+  const marker = '# Added by BoilerCraft';
+  const existing = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+  if (existing.includes(marker)) return null;
+  const lines = [
+    '',
+    marker,
+    `export PATH="${dirs.join(':')}:$PATH"`,
+    hasDotnet ? `export DOTNET_ROOT="${DOTNET_DIR}"` : ''
+  ].filter(l => l !== '').join('\n');
+  fs.appendFileSync(rc, `\n${lines}\n`);
+  return `Added BoilerCraft tools to PATH in ${rc}. Run "source ${rc}" or open a new terminal.`;
+}
+
+const RECIPES = {
+  php: { name: 'PHP', install: installPhp },
+  composer: { name: 'Composer', install: installComposer, after: ['php'] },
+  dotnet: { name: '.NET SDK', install: installDotnet }
+};
+
+function canInstall(tool) {
+  return Object.prototype.hasOwnProperty.call(RECIPES, tool);
+}
+
+/**
+ * Installs the given missing requirements (from checkRequirements) in
+ * dependency order. Returns the names that could not be auto-installed.
+ */
+async function installMissing(missing, log = console.log) {
+  const order = ['php', 'composer', 'dotnet'];
+  const todo = [...missing].sort((a, b) => order.indexOf(a.tool) - order.indexOf(b.tool));
+  const manual = [];
+  for (const m of todo) {
+    if (!canInstall(m.tool)) {
+      manual.push(m);
+      continue;
+    }
+    await RECIPES[m.tool].install({ major: m.major }, log);
+  }
+  const pathNote = await persistPath();
+  if (pathNote) log(pathNote);
+  return manual;
+}
+
+module.exports = { toolEnv, installMissing, persistPath, canInstall, RECIPES, TOOLS_HOME };

package/services/engine/versionCatalog.js

@@ -0,0 +1,115 @@
+const axios = require('axios');
+
+// Lists the framework versions a stack can be scaffolded with, straight from
+// the upstream registry. A new major release shows up here automatically —
+// no code change needed. Majors newer than the stack's "testedUpTo" are still
+// offered, just flagged as untested until someone verifies the overlays.
+
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const cache = new Map();
+
+function majorOf(v) {
+  const m = /^v?(\d+)\./.exec(String(v));
+  return m ? parseInt(m[1], 10) : null;
+}
+
+function isStable(v) {
+  return !/(-|dev|alpha|beta|rc|preview|canary)/i.test(String(v));
+}
+
+function compareVersions(a, b) {
+  const pa = String(a).replace(/^v/, '').split('.').map(n => parseInt(n, 10) || 0);
+  const pb = String(b).replace(/^v/, '').split('.').map(n => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+// Collapses a flat list of version strings into { major -> newest stable }.
+function newestPerMajor(versions, minMajor) {
+  const byMajor = new Map();
+  for (const v of versions) {
+    if (!isStable(v)) continue;
+    const major = majorOf(v);
+    if (major === null || major < minMajor) continue;
+    const current = byMajor.get(major);
+    if (!current || compareVersions(v, current) > 0) byMajor.set(major, v.replace(/^v/, ''));
+  }
+  return [...byMajor.entries()].map(([major, latest]) => ({ major, latest }));
+}
+
+const sources = {
+  async npm({ package: pkg, minMajor = 0 }) {
+    const res = await axios.get(`https://registry.npmjs.org/${encodeURIComponent(pkg)}`, {
+      timeout: 5000,
+      headers: { Accept: 'application/vnd.npm.install-v1+json' } // abbreviated metadata, much smaller
+    });
+    return newestPerMajor(Object.keys(res.data.versions || {}), minMajor);
+  },
+
+  async packagist({ package: pkg, minMajor = 0 }) {
+    const res = await axios.get(`https://repo.packagist.org/p2/${pkg}.json`, { timeout: 5000 });
+    const releases = (res.data.packages && res.data.packages[pkg]) || [];
+    return newestPerMajor(releases.map(r => r.version), minMajor);
+  },
+
+  async dotnet({ minMajor = 0 }) {
+    const res = await axios.get(
+      'https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json',
+      { timeout: 5000 }
+    );
+    return (res.data['releases-index'] || [])
+      .filter(r => r.product === '.NET')
+      .filter(r => r['support-phase'] === 'active' || r['support-phase'] === 'maintenance')
+      .map(r => ({
+        major: majorOf(r['channel-version']),
+        latest: r['latest-release'],
+        lts: r['release-type'] === 'lts'
+      }))
+      .filter(r => r.major !== null && r.major >= minMajor);
+  }
+};
+
+/**
+ * Returns [{ major, latest, tested, lts?, recommended }] newest-first.
+ * Falls back to the manifest's offline list when the registry is unreachable.
+ */
+async function listVersions(stack) {
+  const spec = stack.versions;
+  const key = `${stack.id}`;
+  const hit = cache.get(key);
+  if (hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.list;
+
+  let list;
+  let offline = false;
+  try {
+    const fetcher = sources[spec.source];
+    if (!fetcher) throw new Error(`Unknown version source '${spec.source}'`);
+    list = await fetcher(spec);
+    if (!list.length) throw new Error('registry returned no versions');
+  } catch (err) {
+    console.warn(`[VersionCatalog] ${stack.id}: ${err.message}. Using offline list.`);
+    list = (spec.offline || []).map(major => ({ major, latest: `${major}.x` }));
+    offline = true;
+  }
+
+  const lts = new Set(spec.lts || []);
+  list = list
+    .map(v => ({
+      ...v,
+      lts: v.lts || lts.has(v.major),
+      tested: v.major <= spec.testedUpTo
+    }))
+    .sort((a, b) => b.major - a.major);
+
+  // Recommended = newest tested major; if nothing is tested, the newest one.
+  const recommended = list.find(v => v.tested) || list[0];
+  if (recommended) recommended.recommended = true;
+
+  if (!offline) cache.set(key, { at: Date.now(), list });
+  return list;
+}
+
+module.exports = { listVersions, majorOf, compareVersions };

package/services/generate.js

@@ -0,0 +1,46 @@
+const { generateProject } = require('./projectGenerator');
+const { scaffold, getStack, parseMajor, RequirementError } = require('./engine/scaffoldEngine');
+
+// Shared entry point for the web/desktop server and the CLI.
+
+// The legacy generator expects the old per-stack version formats.
+function toLegacyVersions(config) {
+  const v = config.versions || {};
+  const major = key => parseMajor(v[key]);
+  return {
+    laravel: major('laravel') ? `^${major('laravel')}.0` : v.laravel,
+    nextjs: major('nextjs') ? `^${major('nextjs')}.0.0` : v.nextjs,
+    nodeExpress: major('node-express') ? `^${major('node-express')}.0.0` : v.nodeExpress,
+    dotnet: major('dotnet-core') ? `net${major('dotnet-core')}.0` : v.dotnet
+  };
+}
+
+async function runLegacy(config, warning) {
+  const result = await generateProject({ ...config, versions: toLegacyVersions(config) }, config.outputDir || null);
+  return { ...result, engine: 'legacy', warnings: warning ? [warning] : [] };
+}
+
+/**
+ * Stacks with a manifest in stacks/ are scaffolded by the official-CLI engine.
+ * Everything else (e.g. raw-php) still uses the template generator. If the
+ * required toolchain is missing, fall back to templates unless the caller
+ * opted out with allowLegacyFallback: false.
+ */
+async function generate(config, onLog = () => {}) {
+  const backend = config.backend || config.stack;
+  if (config.engine === 'legacy' || !getStack(backend)) return runLegacy(config);
+
+  try {
+    return await scaffold(config, config.outputDir || null, onLog);
+  } catch (err) {
+    if (err instanceof RequirementError && config.allowLegacyFallback !== false) {
+      const hint = err.missing.map(m => `${m.name}${m.install ? ` (${m.install})` : ''}`).join(', ');
+      const warning = `${err.message}. Used offline templates instead — install ${hint} for an official, version-exact scaffold.`;
+      onLog(`WARNING: ${warning}`);
+      return runLegacy(config, warning);
+    }
+    throw err;
+  }
+}
+
+module.exports = { generate, toLegacyVersions };