freeschema 1.0.0 → 1.0.1

package/bin/freeschema.js

@@ -2,17 +2,78 @@
 
 'use strict';
 
-const { spawnSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const VERSION = require('../package.json').version;
+const { spawnSync }    = require('child_process');
+const fs               = require('fs');
+const path             = require('path');
+const https            = require('https');
+const crypto           = require('crypto');
+const readline         = require('readline');
+
+const VERSION       = require('../package.json').version;
 const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
 
-const args = process.argv.slice(2);
+const args    = process.argv.slice(2);
 const command = args[0];
 
-// ── helpers ──────────────────────────────────────────────────────────────────
+// ── prompt helpers ────────────────────────────────────────────────────────────
+
+function createRL() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, a => resolve(a.trim())));
+}
+
+async function prompt(question, defaultVal = '') {
+  const rl  = createRL();
+  const hint = defaultVal ? ` (${defaultVal})` : '';
+  const ans  = await ask(rl, `${question}${hint}: `);
+  rl.close();
+  return ans || defaultVal;
+}
+
+async function promptSecret(question) {
+  return new Promise(resolve => {
+    const rl = createRL();
+    // hide input on terminals that support it
+    if (process.stdout.isTTY) {
+      process.stdout.write(`${question}: `);
+      const stdin = process.openStdin();
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      let val = '';
+      process.stdin.on('data', function handler(ch) {
+        const c = ch.toString();
+        if (c === '\n' || c === '\r' || c === '') {
+          process.stdin.setRawMode(false);
+          process.stdin.removeListener('data', handler);
+          process.stdout.write('\n');
+          rl.close();
+          resolve(val);
+        } else if (c === '') {
+          val = val.slice(0, -1);
+        } else {
+          val += c;
+        }
+      });
+    } else {
+      ask(rl, `${question}: `).then(v => { rl.close(); resolve(v); });
+    }
+  });
+}
+
+async function choose(question, options, defaultIdx = 0) {
+  console.log(`\n${question}`);
+  options.forEach((o, i) => console.log(`  ${i + 1}) ${o}`));
+  const rl  = createRL();
+  const ans = await ask(rl, `Choice (${defaultIdx + 1}): `);
+  rl.close();
+  const idx = parseInt(ans, 10) - 1;
+  return (idx >= 0 && idx < options.length) ? idx : defaultIdx;
+}
+
+// ── general helpers ───────────────────────────────────────────────────────────
 
 function die(msg) {
   console.error(`\nError: ${msg}\n`);
@@ -30,127 +91,386 @@ function copyRecursive(src, dest) {
   }
 }
 
-function runCompose(composeArgs) {
-  const cwd = process.cwd();
+function setEnvVar(envPath, key, value) {
+  let content = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf8') : '';
+  const escaped = value.replace(/\$/g, '\\$');
+  const re = new RegExp(`^(#\\s*)?${key}=.*`, 'm');
+  if (re.test(content)) {
+    content = content.replace(re, `${key}="${escaped}"`);
+  } else {
+    content += `\n${key}="${escaped}"`;
+  }
+  fs.writeFileSync(envPath, content);
+}
 
+function readEnvVar(envPath, key) {
+  if (!fs.existsSync(envPath)) return '';
+  const m = fs.readFileSync(envPath, 'utf8').match(new RegExp(`^${key}=(.*)`, 'm'));
+  return m ? m[1].replace(/^["']|["']$/g, '').trim() : '';
+}
+
+function generateJwt() {
+  return crypto.randomBytes(32).toString('hex');
+}
+
+function runCompose(composeArgs, opts = {}) {
+  const cwd = process.cwd();
   if (!fs.existsSync(path.join(cwd, 'docker-compose.yml'))) {
-    die('No docker-compose.yml found in the current directory.\nRun `freeschema init` first.');
+    die('No docker-compose.yml found.\nRun `freeschema init` first.');
   }
-
   const result = spawnSync('docker', ['compose', ...composeArgs], {
-    stdio: 'inherit',
-    cwd,
+    stdio: 'inherit', cwd, ...opts,
   });
-
   if (result.error) die(`Could not run docker: ${result.error.message}`);
   if (result.status !== 0) process.exit(result.status);
 }
 
-// ── commands ──────────────────────────────────────────────────────────────────
+function runComposeOutput(composeArgs) {
+  const cwd    = process.cwd();
+  const result = spawnSync('docker', ['compose', ...composeArgs], { cwd });
+  if (result.error) die(`Could not run docker: ${result.error.message}`);
+  return (result.stdout || '').toString().trim();
+}
+
+function getMysqlContainer() {
+  const out        = runComposeOutput(['ps', '--format', 'json']);
+  if (!out) die('No containers running. Start with `freeschema start --local-db` first.');
+  const containers = out.split('\n').map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  const mysql      = containers.find(c => c.Service === 'mysql' || (c.Name || '').includes('mysql-server'));
+  if (!mysql) die('MySQL container is not running.\nStart with `freeschema start --local-db`.');
+  return mysql.Name || mysql.ID;
+}
+
+function readEnv() {
+  const envPath = path.join(process.cwd(), '.env');
+  if (!fs.existsSync(envPath)) return {};
+  const env = {};
+  for (const line of fs.readFileSync(envPath, 'utf8').split('\n')) {
+    const m = line.match(/^([^#=]+)=(.*)/);
+    if (m) env[m[1].trim()] = m[2].trim().replace(/^["']|["']$/g, '');
+  }
+  return env;
+}
+
+// ── init (interactive) ────────────────────────────────────────────────────────
+
+async function cmdInit() {
+  const target  = process.cwd();
+  const envPath = path.join(target, '.env');
+  const envFrontendPath = path.join(target, '.env.frontend');
 
-function cmdInit() {
-  const target = process.cwd();
-  console.log(`Initializing FreeSchema in ${target}\n`);
+  console.log(`\nInitializing FreeSchema in ${target}\n`);
 
+  // 1. Copy template files
   for (const entry of fs.readdirSync(TEMPLATES_DIR)) {
     const src  = path.join(TEMPLATES_DIR, entry);
     const dest = path.join(target, entry);
-
-    if (fs.existsSync(dest)) {
-      console.log(`  skip  ${entry}  (already exists)`);
-      continue;
-    }
-
+    if (fs.existsSync(dest)) { console.log(`  skip   ${entry}`); continue; }
     copyRecursive(src, dest);
     console.log(`  create ${entry}`);
   }
 
-  // .env from example if not present
-  const envFile    = path.join(target, '.env');
+  // Bootstrap .env from example if missing
   const envExample = path.join(target, '.env.example');
-  if (!fs.existsSync(envFile) && fs.existsSync(envExample)) {
-    fs.copyFileSync(envExample, envFile);
-    console.log('  create .env  (copied from .env.example)');
+  if (!fs.existsSync(envPath) && fs.existsSync(envExample)) {
+    fs.copyFileSync(envExample, envPath);
+    console.log('  create .env');
   }
-
-  // .env.frontend from example if not present
-  const envFrontend        = path.join(target, '.env.frontend');
   const envFrontendExample = path.join(target, '.env.frontend.example');
-  if (!fs.existsSync(envFrontend) && fs.existsSync(envFrontendExample)) {
-    fs.copyFileSync(envFrontendExample, envFrontend);
-    console.log('  create .env.frontend  (copied from .env.frontend.example)');
+  if (!fs.existsSync(envFrontendPath) && fs.existsSync(envFrontendExample)) {
+    fs.copyFileSync(envFrontendExample, envFrontendPath);
+    console.log('  create .env.frontend');
+  }
+
+  console.log('\n─────────────────────────────────────────');
+  console.log('  Configuration Setup');
+  console.log('─────────────────────────────────────────\n');
+
+  // 2. JWT Secret
+  const existingJwt = readEnvVar(envPath, 'JWT_SECRET');
+  if (!existingJwt || existingJwt === '') {
+    const jwt = generateJwt();
+    setEnvVar(envPath, 'JWT_SECRET', jwt);
+    console.log('  JWT_SECRET   auto-generated ✓');
+  } else {
+    console.log('  JWT_SECRET   already set ✓');
+  }
+
+  // 3. Database mode
+  const dbChoice = await choose(
+    'Database mode:',
+    ['Local  — spin up a MySQL container (recommended for getting started)',
+     'External — connect to an existing MySQL server (AWS RDS, self-hosted, etc.)'],
+    0
+  );
+
+  if (dbChoice === 0) {
+    // local db
+    setEnvVar(envPath, 'DB_MODE', 'local');
+    setEnvVar(envPath, 'DB_HOST', 'mysql-server');
+    setEnvVar(envPath, 'DB_PORT', '3306');
+
+    console.log('\n  Local MySQL settings (press Enter to keep defaults):');
+    const dbUser = await prompt('  DB username', readEnvVar(envPath, 'MYSQL_USER') || 'freeschema');
+    const dbPass = await prompt('  DB password', readEnvVar(envPath, 'MYSQL_PASSWORD') || 'Freeschema@123');
+    const dbName = await prompt('  DB name',     readEnvVar(envPath, 'MYSQL_DATABASE') || 'freeschema_db');
+    const dbPort = await prompt('  Exposed host port (MySQL)', readEnvVar(envPath, 'MYSQL_PORT') || '3308');
+
+    setEnvVar(envPath, 'DB_USER',               dbUser);
+    setEnvVar(envPath, 'DB_PASSWORD',            dbPass);
+    setEnvVar(envPath, 'DB_DATABASE',            dbName);
+    setEnvVar(envPath, 'MYSQL_USER',             dbUser);
+    setEnvVar(envPath, 'MYSQL_PASSWORD',         dbPass);
+    setEnvVar(envPath, 'MYSQL_DATABASE',         dbName);
+    setEnvVar(envPath, 'MYSQL_ROOT_PASSWORD',    'Admin@' + dbPass);
+    setEnvVar(envPath, 'MYSQL_PORT',             dbPort);
+    setEnvVar(envPath, 'DB_SESSION_DATABASE',    'sessions_db');
+    console.log('  Database     configured (local) ✓');
+  } else {
+    // external db
+    setEnvVar(envPath, 'DB_MODE', 'external');
+    console.log('\n  External database connection:');
+    const dbHost = await prompt('  Host',     '');
+    const dbPort = await prompt('  Port',     '3306');
+    const dbUser = await prompt('  Username', '');
+    const dbPass = await prompt('  Password', '');
+    const dbName = await prompt('  Database name', 'freeschema_db');
+    const dbSess = await prompt('  Session database name', 'sessions_db');
+
+    setEnvVar(envPath, 'DB_HOST',             dbHost);
+    setEnvVar(envPath, 'DB_PORT',             dbPort);
+    setEnvVar(envPath, 'DB_USER',             dbUser);
+    setEnvVar(envPath, 'DB_PASSWORD',         dbPass);
+    setEnvVar(envPath, 'DB_DATABASE',         dbName);
+    setEnvVar(envPath, 'DB_SESSION_DATABASE', dbSess);
+    console.log('  Database     configured (external) ✓');
   }
 
+  // 4. MQTT
+  const mqttChoice = await choose(
+    'MQTT broker:',
+    ['Local  — spin up an Eclipse Mosquitto container',
+     'External — use an existing MQTT broker'],
+    0
+  );
+
+  if (mqttChoice === 0) {
+    setEnvVar(envPath, 'MQTT_HOST', 'mqtt-broker');
+    setEnvVar(envPath, 'MQTT_PORT', '1883');
+    const mqttUser = await prompt('  MQTT username', readEnvVar(envPath, 'MQTT_USERNAME') || 'freeschema');
+    const mqttPass = await prompt('  MQTT password', readEnvVar(envPath, 'MQTT_PASSWORD') || 'freeschema');
+    setEnvVar(envPath, 'MQTT_USERNAME', mqttUser);
+    setEnvVar(envPath, 'MQTT_PASSWORD', mqttPass);
+    console.log('  MQTT         configured (local) ✓');
+  } else {
+    console.log('\n  External MQTT broker:');
+    const mqttHost = await prompt('  Host', '');
+    const mqttPort = await prompt('  Port', '1883');
+    const mqttUser = await prompt('  Username', '');
+    const mqttPass = await prompt('  Password', '');
+    setEnvVar(envPath, 'MQTT_HOST',     mqttHost);
+    setEnvVar(envPath, 'MQTT_PORT',     mqttPort);
+    setEnvVar(envPath, 'MQTT_USERNAME', mqttUser);
+    setEnvVar(envPath, 'MQTT_PASSWORD', mqttPass);
+    console.log('  MQTT         configured (external) ✓');
+  }
+
+  // 5. Nginx port
+  const nginxPort = await prompt('\nNginx port (the port you open in your browser)', readEnvVar(envPath, 'NGINX_PORT') || '80');
+  setEnvVar(envPath, 'NGINX_PORT', nginxPort);
+
+  // 6. Optional — SMTP
+  const smtpChoice = await choose(
+    'SMTP (email sending):',
+    ['Skip for now (can edit .env later)',
+     'Configure now'],
+    0
+  );
+  if (smtpChoice === 1) {
+    const smtpHost = await prompt('  SMTP host', '');
+    const smtpPort = await prompt('  SMTP port', '587');
+    const smtpUser = await prompt('  SMTP username / email', '');
+    const smtpPass = await prompt('  SMTP password', '');
+    const smtpFrom = await prompt('  From address', smtpUser);
+    setEnvVar(envPath, 'SMTP_HOST',         smtpHost);
+    setEnvVar(envPath, 'SMTP_PORT',         smtpPort);
+    setEnvVar(envPath, 'SMTP_USERNAME',     smtpUser);
+    setEnvVar(envPath, 'SMTP_PASSWORD',     smtpPass);
+    setEnvVar(envPath, 'SMTP_FROM_ADDRESS', smtpFrom);
+    console.log('  SMTP         configured ✓');
+  }
+
+  // 7. Summary
+  const localDb   = readEnvVar(envPath, 'DB_MODE') === 'local';
+  const localMqtt = readEnvVar(envPath, 'MQTT_HOST') === 'mqtt-broker';
+
   console.log(`
-Done! Next steps:
-  1. Edit .env with your database, MQTT, SMTP, and JWT settings
-  2. (Optional) Add SQL seed files to seed-db/
-  3. Run one of:
-       freeschema start                        # external DB + MQTT
-       freeschema start --local-db             # spin up local MySQL
-       freeschema start --local-db --local-mqtt  # spin up MySQL + MQTT broker
+─────────────────────────────────────────
+  Setup complete!
+─────────────────────────────────────────
+
+  .env            → configured
+  .env.frontend   → ready (edit if needed)
+  JWT_SECRET      → generated
+
+Next — seed the database then start:
+
+  freeschema db seed --file /path/to/schema.sql
+
+  freeschema start${localDb ? ' --local-db' : ''}${localMqtt ? ' --local-mqtt' : ''}
+
+Open your browser at: http://localhost:${nginxPort}
 `);
 }
 
+// ── start ─────────────────────────────────────────────────────────────────────
+
 function cmdStart() {
+  const cwd     = process.cwd();
+  const missing = ['.env', '.env.frontend'].filter(f => !fs.existsSync(path.join(cwd, f)));
+  if (missing.length) {
+    console.error(`\nMissing required file(s): ${missing.join(', ')}`);
+    console.error('Run `freeschema init` first.\n');
+    process.exit(1);
+  }
+
   const profiles = [];
   const flags    = args.slice(1);
-
   if (flags.includes('--local-db')   || flags.includes('--db'))   profiles.push('--profile', 'local-db');
   if (flags.includes('--local-mqtt') || flags.includes('--mqtt')) profiles.push('--profile', 'local-mqtt');
 
   console.log('Pulling latest FreeSchema images…');
   runCompose([...profiles, 'pull']);
-
   console.log('\nStarting FreeSchema services…');
   runCompose([...profiles, 'up', '-d']);
-
   console.log('\nFreeSchema is running.');
-  console.log('  Logs:   freeschema logs');
   console.log('  Status: freeschema status');
+  console.log('  Logs:   freeschema logs');
   console.log('  Stop:   freeschema stop');
 }
 
-function cmdStop() {
-  console.log('Stopping FreeSchema services…');
-  runCompose(['down']);
-}
+// ── other commands ────────────────────────────────────────────────────────────
 
-function cmdRestart() {
-  const service = args[1];
-  service ? runCompose(['restart', service]) : runCompose(['restart']);
-}
-
-function cmdStatus() {
-  runCompose(['ps']);
-}
+function cmdStop()    { console.log('Stopping…'); runCompose(['down']); }
+function cmdRestart() { const s = args[1]; s ? runCompose(['restart', s]) : runCompose(['restart']); }
+function cmdStatus()  { runCompose(['ps']); }
 
 function cmdLogs() {
-  const service    = args[1];
-  const follow     = !args.includes('--no-follow');
-  const logArgs    = ['logs'];
-  if (follow) logArgs.push('--follow');
+  const service = args[1];
+  const logArgs = ['logs'];
+  if (!args.includes('--no-follow')) logArgs.push('--follow');
   if (service) logArgs.push(service);
   runCompose(logArgs);
 }
 
 function cmdPull() {
-  console.log('Pulling latest FreeSchema images…');
+  console.log('Pulling latest images…');
   runCompose(['pull']);
   console.log('\nDone. Run `freeschema restart` to apply.');
 }
 
 function cmdDown() {
-  const withVolumes = args.includes('--volumes') || args.includes('-v');
-  if (withVolumes) {
-    console.log('Removing containers and volumes…');
-    runCompose(['down', '--volumes']);
-  } else {
-    console.log('Removing containers…');
-    runCompose(['down']);
+  const v = args.includes('--volumes') || args.includes('-v');
+  console.log(v ? 'Removing containers and volumes…' : 'Removing containers…');
+  runCompose(v ? ['down', '--volumes'] : ['down']);
+}
+
+// ── db subcommands ────────────────────────────────────────────────────────────
+
+function cmdDb() {
+  const sub = args[1];
+  switch (sub) {
+    case 'seed':    cmdDbSeed();    break;
+    case 'backup':  cmdDbBackup();  break;
+    case 'restore': cmdDbRestore(); break;
+    default:
+      console.log(`
+freeschema db <subcommand>
+
+  seed    --url <sql-url>      Download a SQL file and place it in seed-db/
+          --file <path>        Copy a local SQL file into seed-db/
+  backup  [file]               Dump database to a .sql file (default: backup-<date>.sql)
+  restore <file>               Restore database from a .sql file
+`);
+  }
+}
+
+function cmdDbSeed() {
+  const urlIdx  = args.indexOf('--url');
+  const fileIdx = args.indexOf('--file');
+  const seedDir = path.join(process.cwd(), 'seed-db');
+  if (!fs.existsSync(seedDir)) fs.mkdirSync(seedDir, { recursive: true });
+
+  if (fileIdx !== -1) {
+    const src = args[fileIdx + 1];
+    if (!src || !fs.existsSync(src)) die(`File not found: ${src}`);
+    const dest = path.join(seedDir, path.basename(src));
+    fs.copyFileSync(src, dest);
+    console.log(`Copied → seed-db/${path.basename(src)}`);
+    console.log('Start with `freeschema start --local-db` — MySQL applies the seed on first boot.');
+    return;
+  }
+
+  if (urlIdx !== -1) {
+    const url  = args[urlIdx + 1];
+    if (!url) die('--url requires a URL');
+    const name = path.basename(new URL(url).pathname) || 'seed.sql';
+    const dest = path.join(seedDir, name);
+    console.log(`Downloading → seed-db/${name}…`);
+    const file = fs.createWriteStream(dest);
+    https.get(url, res => {
+      res.pipe(file);
+      file.on('finish', () => console.log('Done. Run `freeschema start --local-db` to apply on first boot.'));
+    }).on('error', e => { fs.unlinkSync(dest); die(e.message); });
+    return;
   }
+
+  die('Usage:\n  freeschema db seed --url <url>\n  freeschema db seed --file <path>');
 }
 
+function cmdDbBackup() {
+  const env      = readEnv();
+  const dbUser   = env.DB_USER     || env.MYSQL_USER     || 'freeschema';
+  const dbPass   = env.DB_PASSWORD || env.MYSQL_PASSWORD || 'Freeschema@123';
+  const dbName   = env.DB_DATABASE || 'freeschema_db';
+  const dateStr  = new Date().toISOString().slice(0, 19).replace(/[T:]/g, '-');
+  const outFile  = args[2] || `backup-${dateStr}.sql`;
+  const container = getMysqlContainer();
+
+  console.log(`Backing up ${dbName} → ${outFile}…`);
+  const result = spawnSync(
+    'docker',
+    ['exec', container, 'mysqldump', `-u${dbUser}`, `-p${dbPass}`, '--single-transaction', dbName],
+    { stdio: ['inherit', 'pipe', 'inherit'] }
+  );
+  if (result.error || result.status !== 0) die('mysqldump failed — check container logs.');
+  fs.writeFileSync(outFile, result.stdout);
+  console.log(`Backup saved: ${outFile}`);
+}
+
+function cmdDbRestore() {
+  const sqlFile = args[2];
+  if (!sqlFile) die('Usage: freeschema db restore <file.sql>');
+  if (!fs.existsSync(sqlFile)) die(`File not found: ${sqlFile}`);
+
+  const env       = readEnv();
+  const dbUser    = env.DB_USER     || env.MYSQL_USER     || 'freeschema';
+  const dbPass    = env.DB_PASSWORD || env.MYSQL_PASSWORD || 'Freeschema@123';
+  const dbName    = env.DB_DATABASE || 'freeschema_db';
+  const container = getMysqlContainer();
+
+  console.log(`Restoring ${sqlFile} → ${dbName}…`);
+  const result = spawnSync(
+    'docker',
+    ['exec', '-i', container, 'mysql', `-u${dbUser}`, `-p${dbPass}`, dbName],
+    { input: fs.readFileSync(sqlFile), stdio: ['pipe', 'inherit', 'inherit'] }
+  );
+  if (result.error || result.status !== 0) die('Restore failed — check container logs.');
+  console.log('Restore complete.');
+}
+
+// ── help ──────────────────────────────────────────────────────────────────────
+
 function cmdHelp() {
   console.log(`
 FreeSchema CLI v${VERSION}
@@ -159,23 +479,30 @@ Usage:
   freeschema <command> [options]
 
 Commands:
-  init                  Copy config files into the current directory
-  start                 Pull latest images and start all services
-    --local-db          Also start the bundled MySQL container
-    --local-mqtt        Also start the bundled MQTT broker
-  stop                  Stop all running services
-  restart [service]     Restart all services, or a single one
-  status                Show container status (docker compose ps)
-  logs [service]        Stream logs for all services, or one
-    --no-follow         Print logs without following
-  pull                  Pull latest Docker images without restarting
-  down [-v]             Remove containers (add -v to also remove volumes)
+  init                        Interactive setup — creates .env, generates JWT,
+                              configures DB and MQTT
+  start                       Pull latest images and start all services
+    --local-db                  Spin up the bundled MySQL container
+    --local-mqtt                Spin up the bundled MQTT broker
+  stop                        Stop all running services
+  restart [service]           Restart all or one service
+  status                      Show container status
+  logs [service]              Stream logs (--no-follow to print without streaming)
+  pull                        Pull latest images without restarting
+  down [-v]                   Remove containers (-v also removes data volumes)
+
+  db seed --url <url>         Download SQL seed file into seed-db/
+  db seed --file <path>       Copy local SQL file into seed-db/
+  db backup [file]            Dump database to a .sql file
+  db restore <file>           Restore database from a .sql file
 
 Examples:
   freeschema init
   freeschema start --local-db --local-mqtt
+  freeschema db seed --file ./schema.sql
+  freeschema db backup
+  freeschema db restore backup-2026-05-19.sql
   freeschema logs wico-server
-  freeschema restart node-server
   freeschema down -v
 `);
 }
@@ -183,7 +510,7 @@ Examples:
 // ── dispatch ──────────────────────────────────────────────────────────────────
 
 switch (command) {
-  case 'init':    cmdInit();    break;
+  case 'init':    cmdInit().catch(e => { console.error(e); process.exit(1); }); break;
   case 'start':   cmdStart();   break;
   case 'stop':    cmdStop();    break;
   case 'restart': cmdRestart(); break;
@@ -191,15 +518,9 @@ switch (command) {
   case 'logs':    cmdLogs();    break;
   case 'pull':    cmdPull();    break;
   case 'down':    cmdDown();    break;
-  case '--version':
-  case '-v':
-    console.log(VERSION);
-    break;
-  case '--help':
-  case '-h':
-  case undefined:
-    cmdHelp();
-    break;
+  case 'db':      cmdDb();      break;
+  case '--version': case '-v': console.log(VERSION); break;
+  case '--help': case '-h': case undefined: cmdHelp(); break;
   default:
     console.error(`Unknown command: ${command}`);
     cmdHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freeschema",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "FreeSchema — self-hosted deployment CLI",
   "keywords": ["freeschema", "self-hosted", "docker"],
   "homepage": "https://freeschema.com",