@launchframe/cli 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@launchframe/cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Production-ready B2B SaaS boilerplate with subscriptions, credits, and multi-tenancy",
   "main": "src/index.js",
   "bin": {

package/src/commands/cache.js

@@ -3,24 +3,29 @@ const { clearCache, getCacheInfo } = require('../utils/service-cache');
 
 /**
  * Clear service cache
+ * @param {Object} flags - Optional flags
+ * @param {boolean} flags.yes - Skip confirmation prompt
+ * @param {boolean} flags.y - Skip confirmation prompt (short form)
  */
-async function cacheClear() {
+async function cacheClear(flags = {}) {
   console.log(chalk.yellow('\n⚠️  This will delete all cached services'));
   console.log(chalk.gray('You will need to re-download on next init or service:add\n'));
-  
-  const inquirer = require('inquirer');
-  const { confirmed } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirmed',
-    message: 'Continue with cache clear?',
-    default: false
-  }]);
-  
-  if (!confirmed) {
-    console.log('Cancelled');
-    return;
+
+  if (!(flags.yes || flags.y)) {
+    const inquirer = require('inquirer');
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Continue with cache clear?',
+      default: false
+    }]);
+
+    if (!confirmed) {
+      console.log('Cancelled');
+      return;
+    }
   }
-  
+
   await clearCache();
 }
 

package/src/commands/database-console.js

@@ -5,7 +5,7 @@ const inquirer = require('inquirer');
 const { spawnSync } = require('child_process');
 const { requireProject, getProjectConfig } = require('../utils/project-helpers');
 
-async function databaseConsole({ remote = false } = {}) {
+async function databaseConsole({ remote = false, query = null, skipPermission = false } = {}) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -28,23 +28,45 @@ async function databaseConsole({ remote = false } = {}) {
 
     const { vpsUser, vpsHost, vpsAppFolder } = config.deployment;
 
-    // 2. Warn before connecting to production
-    console.log(chalk.yellow.bold('\n⚠️  You are about to connect to the PRODUCTION database.\n'));
-    console.log(chalk.gray(`  Host: ${vpsHost}`));
-    console.log(chalk.gray(`  Folder: ${vpsAppFolder}\n`));
-
-    const { confirmed } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'confirmed',
-        message: 'Are you sure you want to open a console to the production database?',
-        default: false
+    if (query) {
+      // Non-interactive query mode — pipe SQL via stdin, skip confirmation
+      const remoteCmd = `cd ${vpsAppFolder}/infrastructure && docker compose -f docker-compose.yml -f docker-compose.prod.yml exec -T database sh -c 'psql -U $POSTGRES_USER $POSTGRES_DB'`;
+      const result = spawnSync('ssh', ['-T', `${vpsUser}@${vpsHost}`, remoteCmd], {
+        input: query,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        encoding: 'utf8'
+      });
+
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.stderr) process.stderr.write(result.stderr);
+
+      if (result.status !== 0) {
+        console.error(chalk.red('\n❌ Could not execute query on the production database.'));
+        console.log(chalk.gray('Check that the VPS is reachable and services are running.\n'));
+        process.exit(1);
       }
-    ]);
+      return;
+    }
 
-    if (!confirmed) {
-      console.log(chalk.gray('\nAborted.\n'));
-      process.exit(0);
+    // 2. Warn before connecting to production (interactive mode only)
+    if (!skipPermission) {
+      console.log(chalk.yellow.bold('\n⚠️  You are about to connect to the PRODUCTION database.\n'));
+      console.log(chalk.gray(`  Host: ${vpsHost}`));
+      console.log(chalk.gray(`  Folder: ${vpsAppFolder}\n`));
+
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: 'Are you sure you want to open a console to the production database?',
+          default: false
+        }
+      ]);
+
+      if (!confirmed) {
+        console.log(chalk.gray('\nAborted.\n'));
+        process.exit(0);
+      }
     }
 
     console.log(chalk.blue.bold('\n🔌 Connecting to production database...\n'));
@@ -62,6 +84,32 @@ async function databaseConsole({ remote = false } = {}) {
       process.exit(1);
     }
   } else {
+    if (query) {
+      // Non-interactive local query mode — pipe SQL via stdin
+      const psqlCmd = [
+        'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+        'exec', '-T', 'database', 'sh', '-c', 'psql -U $POSTGRES_USER $POSTGRES_DB'
+      ];
+
+      const result = spawnSync('docker', psqlCmd, {
+        cwd: infrastructurePath,
+        input: query,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        encoding: 'utf8'
+      });
+
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.stderr) process.stderr.write(result.stderr);
+
+      if (result.status !== 0) {
+        console.error(chalk.red('\n❌ Could not execute query on the local database container.'));
+        console.log(chalk.gray('Make sure services are running:'));
+        console.log(chalk.white('  launchframe docker:up\n'));
+        process.exit(1);
+      }
+      return;
+    }
+
     console.log(chalk.blue.bold('\n🗄️  Opening local database console...\n'));
 
     // Let the shell inside the container expand $POSTGRES_USER / $POSTGRES_DB

package/src/commands/deploy-sync-features.js

@@ -34,7 +34,7 @@ function sqlBool(val) {
   return val ? 'true' : 'false';
 }
 
-async function deploySyncFeatures() {
+async function deploySyncFeatures(flags = {}) {
   requireProject();
 
   // Step 1 — Project + infrastructure check
@@ -162,18 +162,20 @@ async function deploySyncFeatures() {
   console.log(chalk.gray(`  Remote host:                ${vpsHost}\n`));
   console.log(chalk.red('This will TRUNCATE subscription_plan_features (cascades to feature values).\n'));
 
-  const { confirmed } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'confirmed',
-      message: 'Are you sure you want to sync features to production?',
-      default: false
+  if (!flags.yes) {
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Are you sure you want to sync features to production?',
+        default: false
+      }
+    ]);
+
+    if (!confirmed) {
+      console.log(chalk.gray('\nAborted.\n'));
+      process.exit(0);
     }
-  ]);
-
-  if (!confirmed) {
-    console.log(chalk.gray('\nAborted.\n'));
-    process.exit(0);
   }
 
   // Step 9 — Build sync SQL transaction

package/src/commands/dev-logo.js

@@ -30,12 +30,13 @@ function writeFile(filePath, data) {
 
 /**
  * Generate and inject logo/favicon assets across all relevant frontend services
+ * @param {string} svgPath - Optional path to SVG file (defaults to <projectRoot>/logo.svg)
  */
-async function devLogo() {
+async function devLogo(svgPath) {
   requireProject();
 
   const cwd = process.cwd();
-  const logoPath = path.join(cwd, 'logo.svg');
+  const logoPath = svgPath || path.join(cwd, 'logo.svg');
 
   if (!fs.existsSync(logoPath)) {
     console.error(chalk.red('\n❌ Error: logo.svg not found'));

package/src/commands/docker-logs.js

@@ -1,13 +1,17 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const { requireProject } = require('../utils/project-helpers');
 
 /**
  * View logs from Docker services
+ * @param {string} service - Optional service name to filter logs
+ * @param {Object} flags - Optional flags
+ * @param {boolean} flags['no-follow'] - Snapshot mode: print lines and exit (non-interactive)
+ * @param {number} flags.tail - Number of lines to show (default 100, only used with --no-follow)
  */
-async function dockerLogs() {
+async function dockerLogs(service, flags = {}) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -18,9 +22,24 @@ async function dockerLogs() {
     process.exit(1);
   }
 
-  // Get optional service name from args (e.g., launchframe docker:logs backend)
-  const service = process.argv[3];
+  const noFollow = flags['no-follow'];
 
+  if (noFollow) {
+    // Snapshot mode — print tail and exit (non-interactive, suitable for MCP)
+    const tail = flags.tail || 100;
+    const args = ['-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml', 'logs', '--no-follow', '--tail', String(tail)];
+    if (service) args.push(service);
+
+    try {
+      execSync(`docker-compose ${args.join(' ')}`, { cwd: infrastructurePath, stdio: 'inherit' });
+    } catch (error) {
+      console.error(chalk.red('\n❌ Error viewing logs:'), error.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Streaming mode (interactive)
   console.log(chalk.blue.bold('\n📋 Docker Service Logs\n'));
 
   if (service) {
@@ -34,14 +53,14 @@ async function dockerLogs() {
 
   try {
     const logsCommand = 'docker-compose';
-    const args = ['-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml', 'logs', '-f'];
+    const spawnArgs = ['-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml', 'logs', '-f'];
 
     if (service) {
-      args.push(service);
+      spawnArgs.push(service);
     }
 
     // Use spawn to stream output in real-time
-    const child = spawn(logsCommand, args, {
+    const child = spawn(logsCommand, spawnArgs, {
       cwd: infrastructurePath,
       stdio: 'inherit',
       shell: true

package/src/commands/docker-up.js

@@ -7,8 +7,10 @@ const { requireProject, getProjectConfig } = require('../utils/project-helpers')
 /**
  * Start Docker services (all or specific service)
  * @param {string} serviceName - Optional service name to start (e.g., 'docs', 'backend')
+ * @param {Object} flags - Optional flags
+ * @param {boolean} flags.detach - Run detached (docker-compose up -d) instead of watch mode
  */
-async function dockerUp(serviceName) {
+async function dockerUp(serviceName, flags = {}) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -19,14 +21,26 @@ async function dockerUp(serviceName) {
     process.exit(1);
   }
 
+  if (flags.detach) {
+    // Detached mode — start services in background (no watch, no blocking)
+    const upCommand = serviceName
+      ? `docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d ${serviceName}`
+      : 'docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d';
+
+    console.log(chalk.gray(`Running: ${upCommand}\n`));
+    execSync(upCommand, { cwd: infrastructurePath, stdio: 'inherit' });
+    console.log(chalk.green.bold('\n✅ Services started in detached mode.\n'));
+    return;
+  }
+
   // Check Docker Compose version for watch support
   try {
     const composeVersion = execSync('docker compose version', { encoding: 'utf8' });
     const versionMatch = composeVersion.match(/v?(\d+)\.(\d+)\.(\d+)/);
-    
+
     if (versionMatch) {
       const [, major, minor] = versionMatch.map(Number);
-      
+
       if (major < 2 || (major === 2 && minor < 22)) {
         console.error(chalk.red('\n❌ Error: Docker Compose v2.22+ is required for watch support'));
         console.log(chalk.yellow(`Current version: Docker Compose v${major}.${minor}`));

package/src/commands/migration-create.js

@@ -4,7 +4,7 @@ const chalk = require('chalk');
 const { execSync } = require('child_process');
 const { requireProject } = require('../utils/project-helpers');
 
-async function migrateCreate() {
+async function migrateCreate(migrationName) {
   requireProject();
 
   const infrastructurePath = path.join(process.cwd(), 'infrastructure');
@@ -15,8 +15,6 @@ async function migrateCreate() {
     process.exit(1);
   }
 
-  const migrationName = process.argv[3];
-
   if (!migrationName) {
     console.error(chalk.red('\n❌ Error: migration name is required'));
     console.log(chalk.gray('Usage: launchframe migrate:create <name>\n'));

package/src/commands/module.js

@@ -41,7 +41,7 @@ async function moduleList() {
   console.log('  launchframe module:add <module-name>');
 }
 
-async function moduleAdd(moduleName) {
+async function moduleAdd(moduleName, flags = {}) {
   requireProject();
 
   // Validate module exists in registry
@@ -97,16 +97,18 @@ async function moduleAdd(moduleName) {
   console.log(mod.description);
   console.log(`Affects services: ${mod.services.join(', ')}`);
 
-  const { confirmed } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirmed',
-    message: `Add module "${mod.displayName}" to your project?`,
-    default: true
-  }]);
-
-  if (!confirmed) {
-    console.log('Installation cancelled');
-    process.exit(0);
+  if (!(flags.yes || flags.y)) {
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: `Add module "${mod.displayName}" to your project?`,
+      default: true
+    }]);
+
+    if (!confirmed) {
+      console.log('Installation cancelled');
+      process.exit(0);
+    }
   }
 
   const affectedServices = [...new Set(Object.keys(MODULE_CONFIG[moduleName] || {}))].filter(s => s !== 'infrastructure');
@@ -139,8 +141,8 @@ async function moduleAdd(moduleName) {
     await dockerBuild(service);
   }
 
-  // Restart the full stack in watch mode
-  await dockerUp();
+  // Restart the full stack (detached when running non-interactively, watch otherwise)
+  await dockerUp(undefined, flags.yes || flags.y ? { detach: true } : {});
 }
 
 module.exports = { moduleAdd, moduleList };

package/src/commands/service.js

@@ -10,7 +10,7 @@ const { updateEnvFile } = require('../utils/env-generator');
 const { checkGitHubAccess, showAccessDeniedMessage } = require('../utils/github-access');
 const { ensureCacheReady, getServicePath } = require('../utils/service-cache');
 
-async function serviceAdd(serviceName) {
+async function serviceAdd(serviceName, flags = {}) {
   // STEP 1: Validation
   console.log(chalk.blue(`Installing ${serviceName} service...`));
 
@@ -49,16 +49,18 @@ async function serviceAdd(serviceName) {
   console.log(`Tech stack: ${service.techStack}`);
   console.log(`Dependencies: ${service.dependencies.join(', ')}`);
 
-  const { confirmed } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirmed',
-    message: 'Continue with installation?',
-    default: true
-  }]);
+  if (!(flags.yes || flags.y)) {
+    const { confirmed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Continue with installation?',
+      default: true
+    }]);
 
-  if (!confirmed) {
-    console.log('Installation cancelled');
-    process.exit(0);
+    if (!confirmed) {
+      console.log('Installation cancelled');
+      process.exit(0);
+    }
   }
 
   // STEP 3: Get service files (from cache in production, local in dev)
@@ -124,7 +126,7 @@ async function serviceAdd(serviceName) {
 
   // STEP 4: Service-specific prompts (e.g., Airtable credentials)
   console.log(chalk.blue('\nConfiguring service...'));
-  const envValues = await runServicePrompts(service);
+  const envValues = await runServicePrompts(service, flags);
 
   // STEP 5: Replace template variables
   console.log(chalk.blue('\nCustomizing service for your project...'));
@@ -265,9 +267,17 @@ async function serviceAdd(serviceName) {
   console.log(`\n📖 See README.md in ${serviceName}/ for more details.`);
 }
 
-async function runServicePrompts(service) {
+async function runServicePrompts(service, flags = {}) {
   const envValues = {};
 
+  if (flags.yes || flags.y) {
+    // Non-interactive mode — use empty values; configure manually after install
+    for (const key of Object.keys(service.envVars)) {
+      envValues[key] = '';
+    }
+    return envValues;
+  }
+
   // Prompt for each required env var
   for (const [key, description] of Object.entries(service.envVars)) {
     const { value } = await inquirer.prompt([{

package/src/commands/waitlist-logs.js

@@ -1,11 +1,14 @@
 const chalk = require('chalk');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const { requireProject, getProjectConfig, isWaitlistInstalled } = require('../utils/project-helpers');
 
 /**
- * View waitlist logs from VPS (streaming)
+ * View waitlist logs from VPS
+ * @param {Object} flags - Optional flags
+ * @param {boolean} flags['no-follow'] - Snapshot mode: print tail and exit (non-interactive)
+ * @param {number} flags.tail - Number of lines to show (default 100, used with --no-follow)
  */
-async function waitlistLogs() {
+async function waitlistLogs(flags = {}) {
   requireProject();
 
   console.log(chalk.blue.bold('\n📋 Waitlist Logs\n'));
@@ -28,6 +31,20 @@ async function waitlistLogs() {
 
   const { vpsHost, vpsUser, vpsAppFolder } = config.deployment;
 
+  if (flags['no-follow']) {
+    // Snapshot mode — print tail and exit (non-interactive, suitable for MCP)
+    const tail = flags.tail || 100;
+    const sshCmd = `cd ${vpsAppFolder}/waitlist && docker-compose -f docker-compose.waitlist.yml logs --no-follow --tail=${tail}`;
+
+    const result = spawnSync('ssh', [`${vpsUser}@${vpsHost}`, sshCmd], { stdio: 'inherit' });
+
+    if (result.status !== 0 && result.status !== null) {
+      console.log(chalk.yellow(`\n⚠️  Process exited with code ${result.status}\n`));
+    }
+    return;
+  }
+
+  // Streaming mode (interactive)
   console.log(chalk.gray('Connecting to VPS and streaming logs...\n'));
   console.log(chalk.gray('Press Ctrl+C to exit\n'));
 

package/src/index.js

@@ -63,14 +63,22 @@ function parseFlags(args) {
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg.startsWith('--')) {
-      const flagName = arg.substring(2);
-      const nextArg = args[i + 1];
-      // Check if next arg is a value (not a flag)
-      if (nextArg && !nextArg.startsWith('-')) {
-        flags[flagName] = nextArg;
-        i++; // Skip next arg since we consumed it
+      const withoutDashes = arg.substring(2);
+      const eqIndex = withoutDashes.indexOf('=');
+      if (eqIndex !== -1) {
+        // --key=value format
+        const flagName = withoutDashes.substring(0, eqIndex);
+        flags[flagName] = withoutDashes.substring(eqIndex + 1) || true;
       } else {
-        flags[flagName] = true; // Boolean flag
+        const flagName = withoutDashes;
+        const nextArg = args[i + 1];
+        // Check if next arg is a value (not a flag)
+        if (nextArg && !nextArg.startsWith('-')) {
+          flags[flagName] = nextArg;
+          i++; // Skip next arg since we consumed it
+        } else {
+          flags[flagName] = true; // Boolean flag
+        }
       }
     } else if (arg.startsWith('-') && arg.length === 2) {
       const flagName = arg.substring(1);
@@ -132,7 +140,7 @@ async function main() {
       await deployBuild(args[1]); // Optional service name
       break;
     case 'deploy:sync-features':
-      await deploySyncFeatures();
+      await deploySyncFeatures(flags);
       break;
     case 'waitlist:deploy':
       await waitlistDeploy();
@@ -144,19 +152,19 @@ async function main() {
       await waitlistDown();
       break;
     case 'waitlist:logs':
-      await waitlistLogs();
+      await waitlistLogs(flags);
       break;
     case 'docker:build':
       await dockerBuild(args[1]); // Optional service name
       break;
     case 'docker:up':
-      await dockerUp(args[1]); // Pass optional service name
+      await dockerUp(args[1] || flags.service, flags);
       break;
     case 'docker:down':
       await dockerDown();
       break;
     case 'docker:logs':
-      await dockerLogs();
+      await dockerLogs(args[1] || flags.service, flags);
       break;
     case 'docker:destroy':
       await dockerDestroy({ force: flags.force || flags.f });
@@ -165,24 +173,24 @@ async function main() {
       await migrateRun();
       break;
     case 'migration:create':
-      await migrateCreate();
+      await migrateCreate(args[1] || flags.name);
       break;
     case 'migration:revert':
       await migrateRevert();
       break;
     case 'database:console':
-      await databaseConsole({ remote: flags.remote });
+      await databaseConsole({ remote: flags.remote, query: flags.query, skipPermission: !!flags['skip-permission'] });
       break;
     case 'doctor':
       await doctor();
       break;
     case 'service:add':
-      if (!args[1]) {
+      if (!args[1] && !flags.service) {
         console.error(chalk.red('Error: Service name required'));
         console.log('Usage: launchframe service:add <service-name>');
         process.exit(1);
       }
-      await serviceAdd(args[1]);
+      await serviceAdd(args[1] || flags.service, flags);
       break;
     case 'service:list':
       await serviceList();
@@ -196,18 +204,18 @@ async function main() {
       await serviceRemove(args[1]);
       break;
     case 'module:add':
-      if (!args[1]) {
+      if (!args[1] && !flags.name) {
         console.error(chalk.red('Error: Module name required'));
         console.log('Usage: launchframe module:add <module-name>');
         process.exit(1);
       }
-      await moduleAdd(args[1]);
+      await moduleAdd(args[1] || flags.name, flags);
       break;
     case 'module:list':
       await moduleList();
       break;
     case 'cache:clear':
-      await cacheClear();
+      await cacheClear(flags);
       break;
     case 'cache:info':
       await cacheInfo();
@@ -222,7 +230,7 @@ async function main() {
       await devQueue();
       break;
     case 'dev:logo':
-      await devLogo();
+      await devLogo(args[1] || flags.svg);
       break;
     case 'dev:npm-install':
       if (!args[1]) {