@brezel/installer 1.0.0

package/install.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo "${BLUE}🥨 Welcome to the Brezel Installer!${NC}"
+
+# Check for Node.js
+if ! command -v node >/dev/null 2>&1; then
+    echo "${RED}❌ Node.js is required but not found.${NC}"
+    echo "Please install Node.js 18+ and try again."
+    exit 1
+fi
+
+# Check for npm
+if ! command -v npm >/dev/null 2>&1; then
+    echo "${RED}❌ npm is required but not found.${NC}"
+    exit 1
+fi
+
+# In production, we would use npx -y @kibro/brezel-installer@latest
+# For development/demo purposes in this repo:
+if [ -f "package.json" ] && [ -d "src" ]; then
+    echo "📦 Preparing installer..."
+    npm install --silent
+    npm run build --silent
+fi
+
+if [ -f "./dist/index.js" ]; then
+    echo "🚀 Launching installer..."
+    # Pass all arguments to the TS installer
+    node ./dist/index.js "$@"
+else
+    # Fallback to npx if no local build is found
+    echo "🚀 Fetching and launching latest installer..."
+    npx -y @brezel/installer@latest "$@"
+fi

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@brezel/installer",
+  "version": "1.0.0",
+  "description": "Installer for Brezel",
+  "main": "dist/index.js",
+  "bin": {
+    "brezel-installer": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --clean --minify",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [],
+  "author": "flynamic",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brezelio/installer.git"
+  },
+  "type": "commonjs",
+  "devDependencies": {
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.2.2",
+    "@types/prompts": "^2.4.9",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "execa": "^9.6.1",
+    "ora": "^9.3.0",
+    "prompts": "^2.4.2",
+    "semantic-release": "^25.0.3",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,538 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { execa } from 'execa';
+import fs from 'fs';
+import path from 'path';
+import ora from 'ora';
+
+const program = new Command();
+
+async function runTask(title: string, cmd: string, args: string[], options: any) {
+  const spinner = ora(title).start();
+  const subprocess = execa(cmd, args, { ...options, all: true });
+
+  subprocess.stdout?.on('data', (data) => {
+    const line = data.toString().trim().split('\n').pop();
+    if (line) {
+      spinner.text = `${title} ${chalk.dim(`(${line.substring(0, 60).trim()}...)`)}`;
+    }
+  });
+
+  subprocess.stderr?.on('data', (data) => {
+    const line = data.toString().trim().split('\n').pop();
+    if (line) {
+      spinner.text = `${title} ${chalk.dim(`(${line.substring(0, 60).trim()}...)`)}`;
+    }
+  });
+
+  try {
+    await subprocess;
+    spinner.succeed(title);
+  } catch (e: any) {
+    spinner.fail(`${title} failed.`);
+    if (e.all) console.error(chalk.red(e.all));
+    process.exit(1);
+  }
+}
+
+program
+  .name('brezel-installer')
+  .description('Installer for Brezel (SPA + API)')
+  .version('1.0.0')
+  .option('-d, --dir <directory>', 'Installation directory', './brezel')
+  .option('-m, --mode <mode>', 'Installation mode (native, docker)', 'native')
+  .option('-s, --system <name>', 'System name', 'example')
+  .option('-u, --url <url>', 'API URL', 'http://brezel-api.test')
+  .option('--spa-url <url>', 'SPA URL', 'http://localhost:5173')
+  .option('--db-host <host>', 'Database host', '127.0.0.1')
+  .option('--db-port <port>', 'Database port', '3306')
+  .option('--db-name <name>', 'Database name', 'brezel_meta')
+  .option('--db-user <user>', 'Database user', 'root')
+  .option('--db-password <password>', 'Database password', '')
+  .option('--php-path <path>', 'Path to PHP executable', 'php')
+  .option('--gitlab-token <token>', 'GitLab Personal Access Token')
+  .option('--no-interactive', 'Run in non-interactive mode')
+  .option('--source-mode <mode>', 'Source control mode (clone, fork)', 'clone')
+  .option('--components <list>', 'Optional components to install (mariadb, nginx, ssl, cron)', '');
+
+const REPO_SKELETON = 'https://github.com/brezelio/brezel.git';
+
+program.action(async (options) => {
+  console.log(chalk.bold.blue('\n🥨 Welcome to the Brezel Installer!\n'));
+
+  const checkPhp = async (phpPath: string) => {
+    try {
+        const { stdout } = await execa(phpPath, ['-r', 'echo PHP_VERSION;']);
+        // Use regex to find the version string (e.g. 8.3.1 or 8.4.14) in case of warnings
+        const match = stdout.match(/(\d+)\.(\d+)\.(\d+)/);
+        if (!match) return null;
+
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        const version = match[0];
+
+        return {
+            version,
+            valid: (major > 8 || (major === 8 && minor >= 3))
+        };
+    } catch (e) {
+        return null;
+    }
+  };
+
+  // 1. Prerequisites Check
+  const spinner = ora('Checking prerequisites...').start();
+  const checks: any = {};
+  
+  try {
+    // Critical Deps
+    for (const dep of ['git', 'node', 'npm']) {
+      await execa(dep, ['--version']);
+      checks[dep] = true;
+    }
+
+    // PHP version check
+    const phpResult = await checkPhp(options.phpPath || 'php');
+    if (phpResult) {
+        checks.php = phpResult.version;
+        checks.phpValid = phpResult.valid;
+    } else {
+        checks.php = false;
+        checks.phpValid = false;
+    }
+
+    // Composer check
+    try {
+        await execa('composer', ['--version']);
+        checks.composer = true;
+    } catch (e) {
+        checks.composer = false;
+    }
+
+    // Docker check
+    try {
+        await execa('docker', ['--version']);
+        checks.docker = true;
+    } catch (e) {
+        checks.docker = false;
+    }
+
+    // Valet check (macOS only)
+    if (process.platform === 'darwin') {
+        try {
+            await execa('valet', ['--version']);
+            checks.valet = true;
+        } catch (e) {
+            checks.valet = false;
+        }
+    }
+
+    spinner.succeed('System check complete.');
+  } catch (error) {
+    spinner.fail('Missing critical prerequisites (git, node, or npm).');
+    process.exit(1);
+  }
+
+  let responses = options;
+
+  if (options.interactive !== false) {
+    const interactiveResponses = await prompts([
+      {
+        type: 'select',
+        name: 'mode',
+        message: 'How do you want to install Brezel?',
+        choices: [
+          { 
+            title: `Native (Bare metal) ${!checks.phpValid && checks.php ? chalk.yellow('(PHP 8.3+ required, current: ' + checks.php + ')') : (!checks.php ? chalk.red('(PHP not found)') : '')}`, 
+            value: 'native',
+            disabled: false
+          },
+          ...(checks.valet ? [{
+            title: `Valet (macOS Magic) ${chalk.dim('- handles domain mapping automatically')}`,
+            value: 'valet'
+          }] : []),
+          { 
+            title: `Docker (Containerized) ${!checks.docker ? chalk.red('(Docker required)') : ''}`, 
+            value: 'docker',
+            disabled: !checks.docker
+          }
+        ],
+        initial: (options.mode === 'valet' && checks.valet) ? 1 : ((options.mode === 'docker' && checks.docker) ? (checks.valet ? 2 : 1) : 0)
+      },
+      {
+        type: (prev, values) => (values.mode === 'native' || values.mode === 'valet') ? 'text' : null,
+        name: 'phpPath',
+        message: 'Path to PHP 8.3+ executable:',
+        initial: options.phpPath || 'php',
+        validate: async (val) => {
+            const res = await checkPhp(val);
+            if (!res) return 'PHP not found at this path.';
+            if (!res.valid) return `PHP version ${res.version} is too old. 8.3+ required.`;
+            return true;
+        }
+      },
+      {
+        type: 'select',
+        name: 'sourceMode',
+        message: 'Source control mode:',
+        choices: [
+          { title: 'Clone without history', value: 'clone' },
+          { title: 'Fork and clone', value: 'fork' }
+        ],
+        initial: options.sourceMode === 'fork' ? 1 : 0
+      },
+      {
+        type: (prev) => prev === 'fork' ? 'text' : null,
+        name: 'forkUrl',
+        message: 'Enter your fork URL (git@...):',
+        validate: (v) => v.length > 0 ? true : 'Fork URL is required'
+      },
+      {
+        type: 'text',
+        name: 'gitlabToken',
+        message: 'GitLab Personal Access Token (for @kibro packages, scope: read_api, read_registry)',
+        initial: options.gitlabToken,
+        validate: (v) => (v && v.length > 0) ? true : 'Token is required'
+      },
+      {
+        type: 'text',
+        name: 'dir',
+        message: 'Installation directory:',
+        initial: options.dir
+      },
+      {
+        type: 'text',
+        name: 'system',
+        message: 'System name:',
+        initial: options.system
+      },
+      {
+        type: 'text',
+        name: 'url',
+        message: 'API URL:',
+        initial: (prev: any, values: any) => options.url !== 'http://brezel-api.test' ? options.url : `http://${values.system}.test`
+      },
+      {
+        type: 'text',
+        name: 'spaUrl',
+        message: 'SPA URL:',
+        initial: (prev: any, values: any) => {
+            if (options.spaUrl !== 'http://localhost:5173') return options.spaUrl;
+            if (values.mode === 'valet') return `http://${values.system}.test:5173`;
+            return `http://localhost:5173`;
+        }
+      },
+      {
+        type: 'multiselect',
+        name: 'components',
+        message: 'Select optional components to install:',
+        choices: [
+          { title: 'MariaDB', value: 'mariadb' },
+          { title: 'Nginx', value: 'nginx' },
+          { title: 'SSL (Certbot)', value: 'ssl' },
+          { title: 'Cron jobs', value: 'cron' }
+        ],
+        initial: (options.components && typeof options.components === 'string') 
+                    ? options.components.split(',').map(c => ['mariadb', 'nginx', 'ssl', 'cron'].indexOf(c))
+                    : undefined
+      },
+      {
+        type: 'text',
+        name: 'dbHost',
+        message: 'Database Host',
+        initial: options.dbHost
+      },
+      {
+        type: 'text',
+        name: 'dbPort',
+        message: 'Database Port',
+        initial: options.dbPort
+      },
+      {
+        type: 'text',
+        name: 'dbName',
+        message: 'Database Name',
+        initial: options.dbName
+      },
+      {
+        type: 'text',
+        name: 'dbUser',
+        message: 'Database User',
+        initial: options.dbUser
+      },
+      {
+        type: 'password',
+        name: 'dbPassword',
+        message: 'Database Password',
+        initial: options.dbPassword
+      }
+    ]);
+
+    responses = { ...options, ...interactiveResponses };
+  } else {
+      // In non-interactive mode, parse components string into array
+      if (typeof responses.components === 'string') {
+          responses.components = responses.components.split(',').filter(Boolean);
+      }
+  }
+
+  if (!responses.dir) process.exit(1);
+
+  // Validation after response
+  const isNative = responses.mode === 'native' || responses.mode === 'valet';
+
+  if (isNative) {
+    const phpRes = await checkPhp(responses.phpPath);
+    if (!phpRes || !phpRes.valid) {
+        ora(`Native/Valet mode requires PHP 8.3+, but version ${phpRes?.version || 'none'} was found at ${responses.phpPath}.`).fail();
+        process.exit(1);
+    }
+    if (!checks.composer) {
+        ora('Native/Valet mode requires Composer, but it was not found.').fail();
+        process.exit(1);
+    }
+  } else if (responses.mode === 'docker' && !checks.docker) {
+      ora('Docker mode requires Docker, but it was not found.').fail();
+      process.exit(1);
+  }
+
+  const rootDir = path.resolve(responses.dir);
+  
+  if (!fs.existsSync(rootDir)) {
+    const s = ora(`Cloning Brezel skeleton (${responses.sourceMode === 'clone' ? 'no history' : 'fork'})...`).start();
+    try {
+      const cloneUrl = responses.sourceMode === 'fork' ? responses.forkUrl : REPO_SKELETON;
+      const cloneArgs = ['clone'];
+      if (responses.sourceMode === 'clone') {
+          cloneArgs.push('--depth', '1');
+      }
+      cloneArgs.push(cloneUrl, rootDir);
+      
+      await execa('git', cloneArgs);
+      
+      if (responses.sourceMode === 'clone') {
+          fs.rmSync(path.join(rootDir, '.git'), { recursive: true, force: true });
+          await execa('git', ['init'], { cwd: rootDir });
+          await execa('git', ['add', '.'], { cwd: rootDir });
+          await execa('git', ['commit', '-m', 'Initial commit from Brezel Installer'], { cwd: rootDir });
+      }
+      
+      s.succeed('Brezel skeleton cloned.');
+    } catch (e) {
+      s.fail('Failed to clone repository.');
+      console.error(e);
+      process.exit(1);
+    }
+  }
+
+  // 2. Optional Components (Bare metal only)
+  if (responses.mode === 'native' && responses.components && responses.components.length > 0) {
+      console.log(chalk.bold.cyan('\n🛠 Installing optional components...'));
+      for (const component of responses.components) {
+          const compSpinner = ora(`Installing ${component}...`).start();
+          try {
+              if (process.platform === 'linux') {
+                  if (component === 'mariadb') {
+                      await execa('sudo', ['apt-get', 'update']);
+                      await execa('sudo', ['apt-get', 'install', '-y', 'mariadb-server']);
+                      compSpinner.succeed('MariaDB installed.');
+                  } else if (component === 'nginx') {
+                      await execa('sudo', ['apt-get', 'install', '-y', 'nginx']);
+                      compSpinner.succeed('Nginx installed.');
+                  } else if (component === 'ssl') {
+                      await execa('sudo', ['apt-get', 'install', '-y', 'certbot', 'python3-certbot-nginx']);
+                      compSpinner.succeed('Certbot installed.');
+                  } else if (component === 'cron') {
+                      const cronJob = `* * * * * cd ${rootDir} && ${responses.phpPath} bakery schedule:run >> /dev/null 2>&1`;
+                      compSpinner.info('Cron job suggested: ' + cronJob);
+                  }
+              } else if (process.platform === 'darwin') {
+                  if (component === 'mariadb') {
+                      await execa('brew', ['install', 'mariadb']);
+                      compSpinner.succeed('MariaDB installed via Homebrew.');
+                  } else if (component === 'nginx') {
+                      await execa('brew', ['install', 'nginx']);
+                      compSpinner.succeed('Nginx installed via Homebrew.');
+                  } else {
+                      compSpinner.warn(`${component} installation not fully automated for macOS.`);
+                  }
+              } else {
+                  compSpinner.warn(`${component} installation not supported on this OS.`);
+              }
+          } catch (e) {
+              compSpinner.fail(`Failed to install ${component}.`);
+          }
+      }
+  }
+
+  if (responses.mode === 'docker') {
+      console.log(chalk.bold.cyan('\n🐳 Setting up Docker environment...'));
+
+      const envExamplePath = path.join(rootDir, '.env.example');
+      const envPath = path.join(rootDir, '.env');
+      
+      if (fs.existsSync(envExamplePath)) {
+        let envContent = fs.readFileSync(envExamplePath, 'utf-8');
+        
+        envContent = envContent.replace(/APP_URL=.*/, `APP_URL=${responses.url}`);
+        envContent = envContent.replace(/VITE_APP_API_URL=.*/, `VITE_APP_API_URL=${responses.url}`);
+        envContent = envContent.replace(/VITE_APP_SYSTEM=.*/, `VITE_APP_SYSTEM=${responses.system}`);
+        envContent = envContent.replace(/TENANCY_HOST=.*/, `TENANCY_HOST=db`);
+        envContent = envContent.replace(/TENANCY_PASSWORD=.*/, `TENANCY_PASSWORD=password`); 
+        
+        if (!envContent.includes('APP_SYSTEM=')) {
+            envContent += `\nAPP_SYSTEM=${responses.system}\n`;
+        } else {
+            envContent = envContent.replace(/APP_SYSTEM=.*/, `APP_SYSTEM=${responses.system}`);
+        }
+
+        fs.writeFileSync(envPath, envContent);
+        ora('Configured .env for Docker').succeed();
+      }
+
+      await runTask('Building and starting Docker containers', 'docker', ['compose', 'up', '-d', '--build'], {
+          cwd: rootDir,
+          env: {
+              ...process.env,
+              COMPOSER_TOKEN: responses.gitlabToken,
+              NPM_TOKEN: responses.gitlabToken,
+              APP_SYSTEM: responses.system,
+              APP_URL: responses.url
+          }
+      });
+      
+      console.log(chalk.bold.cyan('\n🥐 Initializing Brezel in Docker...'));
+          const initSpinner = ora('Waiting for database...').start();
+          
+          await new Promise(r => setTimeout(r, 10000));
+          
+          const runDockerCmd = async (cmd: string[]) => {
+              await execa('docker', ['compose', 'exec', 'api', ...cmd], { cwd: rootDir, stdio: 'inherit' });
+          };
+          
+          try {
+              initSpinner.text = 'Running bakery init...';
+              await runDockerCmd(['php', 'bakery', 'init']);
+              
+              console.log(chalk.dim(`Creating system "${responses.system}"...`));
+              await runDockerCmd(['php', 'bakery', 'system', 'create', responses.system]);
+              
+              console.log(chalk.dim('Applying system config...'));
+              await runDockerCmd(['php', 'bakery', 'apply']);
+              
+              initSpinner.succeed('Brezel initialized in Docker.');
+              
+          } catch (e) {
+              initSpinner.fail('Initialization in Docker failed.');
+              console.error(e);
+          }
+      
+      console.log(chalk.bold.green('\n✅ Docker Installation complete!'));
+      console.log(chalk.white(`
+Services are running:
+  API: ${responses.url} (mapped to localhost:8081)
+  SPA: ${responses.spaUrl} (mapped to localhost:3000)
+  
+To stop:
+  cd ${rootDir}
+  docker compose down
+`));
+      
+      return;
+  }
+
+  // 3. Install Dependencies (Native/Valet Mode)
+  if (isNative) {
+    console.log(chalk.bold.cyan('\n📦 Installing Dependencies...'));
+    
+    await execa('composer', ['config', 'gitlab-token.gitlab.kiwis-and-brownies.de', responses.gitlabToken], { cwd: rootDir });
+
+    await runTask('Installing PHP dependencies (Composer)', 'composer', ['install', '--no-interaction'], { cwd: rootDir });
+
+    const npmrcPath = path.join(rootDir, '.npmrc');
+    const npmrcContent = `
+@kibro:registry=https://gitlab.kiwis-and-brownies.de/api/v4/packages/npm/
+//gitlab.kiwis-and-brownies.de/api/v4/packages/npm/:_authToken=${responses.gitlabToken}
+`;
+    fs.writeFileSync(npmrcPath, npmrcContent);
+
+    await runTask('Installing Node dependencies (npm)', 'npm', ['install'], { cwd: rootDir });
+
+    const envExamplePath = path.join(rootDir, '.env.example');
+    const envPath = path.join(rootDir, '.env');
+    if (fs.existsSync(envExamplePath)) {
+      let envContent = fs.readFileSync(envExamplePath, 'utf-8');
+      
+      envContent = envContent.replace(/APP_URL=.*/, `APP_URL=${responses.url}`);
+      envContent = envContent.replace(/VITE_APP_API_URL=.*/, `VITE_APP_API_URL=${responses.url}`);
+      envContent = envContent.replace(/VITE_APP_SYSTEM=.*/, `VITE_APP_SYSTEM=${responses.system}`);
+      
+      envContent = envContent.replace(/TENANCY_HOST=.*/, `TENANCY_HOST=${responses.dbHost}`);
+      envContent = envContent.replace(/TENANCY_PORT=.*/, `TENANCY_PORT=${responses.dbPort}`);
+      envContent = envContent.replace(/TENANCY_DATABASE=.*/, `TENANCY_DATABASE=${responses.dbName}`);
+      envContent = envContent.replace(/TENANCY_USERNAME=.*/, `TENANCY_USERNAME=${responses.dbUser}`);
+      envContent = envContent.replace(/TENANCY_PASSWORD=.*/, `TENANCY_PASSWORD=${responses.dbPassword}`);
+      
+      fs.writeFileSync(envPath, envContent);
+      ora('Configured .env').succeed();
+    }
+
+    console.log(chalk.bold.cyan('\n🥐 Initializing Brezel...'));
+    
+    const runBakery = async (args: string[]) => {
+        await execa(responses.phpPath, ['bakery', ...args], { cwd: rootDir, stdio: 'inherit' });
+    };
+
+    try {
+        console.log(chalk.dim('Running initialization...'));
+        await runBakery(['init']);
+        console.log(chalk.dim(`Creating system "${responses.system}"...`));
+        await runBakery(['system', 'create', responses.system]);
+        console.log(chalk.dim('Applying system config...'));
+        await runBakery(['apply']);
+    } catch (e) {
+        console.error(chalk.red('Initialization failed.'));
+        console.error(e);
+    }
+    
+    await runTask('Building SPA', 'npm', ['run', 'build'], { cwd: rootDir });
+
+    // Valet specific setup
+    if (responses.mode === 'valet') {
+        console.log(chalk.bold.cyan('\n🎩 Valet Setup...'));
+        try {
+            await execa('valet', ['link', responses.system], { cwd: rootDir });
+            ora(`Linked ${responses.system}.test to Valet.`).succeed();
+            
+            // Try to secure it
+            if (responses.url.startsWith('https://')) {
+                await execa('valet', ['secure', responses.system], { cwd: rootDir });
+                ora(`Secured ${responses.system}.test with SSL.`).succeed();
+            }
+        } catch (e) {
+            console.warn(chalk.yellow('Valet link/secure failed. You might need to run it manually.'));
+        }
+    }
+  }
+
+  console.log(chalk.bold.cyan('\n📦 Installing Export Services...'));
+  try {
+    await execa('npx', ['@kibro/export-installer@latest'], { stdio: 'inherit' });
+  } catch (e) {
+    console.warn(chalk.yellow('Export services installer finished with warning or error.'));
+  }
+
+  console.log(chalk.bold.green('\n✅ Installation complete!'));
+  console.log(chalk.white(`
+To start the server (API + SPA dev):
+  cd ${responses.dir}
+  npm run dev
+
+For Windows users:
+  bin\\serve_on_windows.ps1
+`));
+});
+
+program.parse();