@launchframe/cli 1.0.0-beta.9 → 1.0.1

package/src/commands/deploy-set-env.js

@@ -71,7 +71,7 @@ async function deploySetEnv() {
   // Generate secure defaults
   const dbPassword = generateSecret(24);
   const redisPassword = generateSecret(24);
-  const jwtSecret = generateSecret(32);
+  const betterAuthSecret = generateSecret(32);
   const bullAdminToken = generateSecret(32);
 
   const answers = await inquirer.prompt([
@@ -91,9 +91,9 @@ async function deploySetEnv() {
     },
     {
       type: 'password',
-      name: 'jwtSecret',
-      message: 'JWT secret:',
-      default: jwtSecret,
+      name: 'betterAuthSecret',
+      message: 'Better Auth secret (min 32 chars):',
+      default: betterAuthSecret,
       mask: '*'
     },
     {
@@ -143,7 +143,7 @@ async function deploySetEnv() {
 
   replacements['DB_PASSWORD'] = answers.dbPassword;
   replacements['REDIS_PASSWORD'] = answers.redisPassword;
-  replacements['JWT_SECRET'] = answers.jwtSecret;
+  replacements['BETTER_AUTH_SECRET'] = answers.betterAuthSecret;
   replacements['BULL_ADMIN_TOKEN'] = answers.bullAdminToken;
   replacements['RESEND_API_KEY'] = answers.resendApiKey || 're_your_resend_api_key';
   replacements['POLAR_ACCESS_TOKEN'] = answers.polarAccessToken || 'polar_oat_your_token';
@@ -163,11 +163,21 @@ async function deploySetEnv() {
   // Update production URLs based on deployment config
   if (config.deployment?.primaryDomain) {
     const domain = config.deployment.primaryDomain;
+    const adminEmail = config.deployment.adminEmail || `admin@${domain}`;
+
+    // First, replace all {{PRIMARY_DOMAIN}} and {{ADMIN_EMAIL}} placeholders globally
+    envContent = envContent.split('{{PRIMARY_DOMAIN}}').join(domain);
+    envContent = envContent.split('{{ADMIN_EMAIL}}').join(adminEmail);
+
+    // Then update specific URL variables for production
     const urlReplacements = {
+      'PRIMARY_DOMAIN': domain,
+      'NODE_ENV': 'production',
       'API_BASE_URL': `https://api.${domain}`,
       'ADMIN_BASE_URL': `https://admin.${domain}`,
-      'FRONTEND_BASE_URL': `https://app.${domain}`,
-      'WEBSITE_BASE_URL': `https://${domain}`
+      'FRONTEND_BASE_URL': `https://${domain}`,
+      'WEBSITE_BASE_URL': `https://www.${domain}`,
+      'GOOGLE_REDIRECT_URI': `https://api.${domain}/auth/google/callback`
     };
 
     for (const [key, value] of Object.entries(urlReplacements)) {

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

@@ -0,0 +1,235 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { spawnSync } = require('child_process');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+
+function localQuery(infrastructurePath, sql) {
+  return spawnSync('docker', [
+    'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+    'exec', '-T', 'database', 'sh', '-c', 'psql -U $POSTGRES_USER $POSTGRES_DB -t -A'
+  ], { cwd: infrastructurePath, input: sql, encoding: 'utf8' });
+}
+
+function remoteQuery(vpsUser, vpsHost, vpsAppFolder, sql) {
+  return spawnSync('ssh', [
+    `${vpsUser}@${vpsHost}`,
+    `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 -t -A'`
+  ], { input: sql, encoding: 'utf8' });
+}
+
+function sqlStr(val) {
+  if (val === null || val === undefined) return 'NULL';
+  return `'${String(val).replace(/'/g, "''")}'`;
+}
+
+function sqlJsonb(val) {
+  if (val === null || val === undefined) return 'NULL';
+  return `'${JSON.stringify(val).replace(/'/g, "''")}'::jsonb`;
+}
+
+function sqlBool(val) {
+  return val ? 'true' : 'false';
+}
+
+async function deploySyncFeatures(flags = {}) {
+  requireProject();
+
+  // Step 1 — Project + infrastructure check
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+
+  if (!fs.existsSync(infrastructurePath)) {
+    console.error(chalk.red('\n❌ Error: infrastructure/ directory not found'));
+    console.log(chalk.gray('Make sure you are in the root of your LaunchFrame project.\n'));
+    process.exit(1);
+  }
+
+  // Step 2 — Deployment configured
+  const config = getProjectConfig();
+
+  if (!config.deployConfigured || !config.deployment) {
+    console.error(chalk.red('\n❌ Deployment is not configured.'));
+    console.log(chalk.gray('Run deploy:configure first.\n'));
+    process.exit(1);
+  }
+
+  const { vpsUser, vpsHost, vpsAppFolder } = config.deployment;
+
+  // Step 3 — Local database container up
+  const localPs = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'ps', '--status', 'running', '-q', 'database'
+    ],
+    { cwd: infrastructurePath, encoding: 'utf8' }
+  );
+
+  if (!localPs.stdout || localPs.stdout.trim() === '') {
+    console.error(chalk.red('\n❌ Local database container is not running.'));
+    console.log(chalk.gray('Run: launchframe docker:up\n'));
+    process.exit(1);
+  }
+
+  // Step 4 — Remote database container up
+  const remoteDockerPsCmd = `cd ${vpsAppFolder}/infrastructure && docker compose -f docker-compose.yml -f docker-compose.prod.yml ps --status running -q database`;
+  const remotePs = spawnSync('ssh', [`${vpsUser}@${vpsHost}`, remoteDockerPsCmd], { encoding: 'utf8' });
+
+  if (remotePs.status !== 0 || !remotePs.stdout || remotePs.stdout.trim() === '') {
+    console.error(chalk.red('\n❌ Remote database container is not running.'));
+    console.log(chalk.gray('Make sure services are running: launchframe deploy:up\n'));
+    process.exit(1);
+  }
+
+  // Step 5 — Remote Polar sync check
+  const polarCountResult = remoteQuery(
+    vpsUser, vpsHost, vpsAppFolder,
+    'SELECT COUNT(*) FROM subscription_plans WHERE polar_product_id IS NOT NULL;'
+  );
+
+  const polarCount = parseInt((polarCountResult.stdout || '').trim(), 10);
+  if (!polarCount || polarCount === 0) {
+    console.error(chalk.red('\n❌ Remote plans have not been synced from Polar yet.'));
+    console.log(chalk.gray('Import plans from the admin portal first.\n'));
+    process.exit(1);
+  }
+
+  // Step 6 — Compare plans local vs remote
+  const planCodesSQL = 'SELECT json_agg(code ORDER BY sort_order) FROM subscription_plans;';
+
+  const localPlansResult = localQuery(infrastructurePath, planCodesSQL);
+  const remotePlansResult = remoteQuery(vpsUser, vpsHost, vpsAppFolder, planCodesSQL);
+
+  let localCodes = [];
+  let remoteCodes = [];
+
+  try {
+    localCodes = JSON.parse((localPlansResult.stdout || '').trim()) || [];
+  } catch {
+    localCodes = [];
+  }
+
+  try {
+    remoteCodes = JSON.parse((remotePlansResult.stdout || '').trim()) || [];
+  } catch {
+    remoteCodes = [];
+  }
+
+  const missingOnRemote = localCodes.filter(code => !remoteCodes.includes(code));
+  if (missingOnRemote.length > 0) {
+    console.error(chalk.red(`\n❌ Some local plans are missing on remote: ${missingOnRemote.join(', ')}`));
+    console.log(chalk.gray('Ensure plans are imported from Polar on the remote admin portal.\n'));
+    process.exit(1);
+  }
+
+  // Step 7 — Query local data (for summary counts)
+  const featuresSQL = `SELECT json_agg(row_to_json(t)) FROM (
+    SELECT name, code, description, feature_type, default_value, template, is_active, sort_order
+    FROM subscription_plan_features ORDER BY sort_order
+  ) t;`;
+
+  const featureValuesSQL = `SELECT json_agg(row_to_json(t)) FROM (
+    SELECT sp.code AS plan_code, spf.code AS feature_code, spfv.value
+    FROM subscription_plan_feature_values spfv
+    JOIN subscription_plans sp ON sp.id = spfv.subscription_plan_id
+    JOIN subscription_plan_features spf ON spf.id = spfv.feature_id
+  ) t;`;
+
+  const featuresResult = localQuery(infrastructurePath, featuresSQL);
+  const featureValuesResult = localQuery(infrastructurePath, featureValuesSQL);
+
+  let features = [];
+  let featureValues = [];
+
+  try {
+    features = JSON.parse((featuresResult.stdout || '').trim()) || [];
+  } catch {
+    features = [];
+  }
+
+  try {
+    featureValues = JSON.parse((featureValuesResult.stdout || '').trim()) || [];
+  } catch {
+    featureValues = [];
+  }
+
+  // Step 7 cont — Show summary + confirm
+  console.log(chalk.yellow.bold('\n⚠️  You are about to overwrite ALL features on the PRODUCTION database.\n'));
+  console.log(chalk.gray(`  Local features:             ${features.length}`));
+  console.log(chalk.gray(`  Local feature-plan values:  ${featureValues.length}`));
+  console.log(chalk.gray(`  Remote host:                ${vpsHost}\n`));
+  console.log(chalk.red('This will TRUNCATE subscription_plan_features (cascades to feature values).\n'));
+
+  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);
+    }
+  }
+
+  // Step 9 — Build sync SQL transaction
+  const featureRows = features.map(f =>
+    `(${sqlStr(f.name)}, ${sqlStr(f.code)}, ${sqlStr(f.description)}, ${sqlStr(f.feature_type)}, ${sqlJsonb(f.default_value)}, ${sqlStr(f.template)}, ${sqlBool(f.is_active)}, ${f.sort_order !== null && f.sort_order !== undefined ? f.sort_order : 'NULL'}, NOW(), NOW())`
+  ).join(',\n  ');
+
+  const featureValueRows = featureValues.map(v =>
+    `(${sqlStr(v.plan_code)}, ${sqlStr(v.feature_code)}, ${sqlJsonb(v.value)})`
+  ).join(',\n  ');
+
+  let syncSql = `BEGIN;\n\nTRUNCATE subscription_plan_features CASCADE;\n`;
+
+  if (features.length > 0) {
+    syncSql += `
+INSERT INTO subscription_plan_features
+  (name, code, description, feature_type, default_value, template, is_active, sort_order, created_at, updated_at)
+VALUES
+  ${featureRows};
+`;
+  }
+
+  if (featureValues.length > 0) {
+    syncSql += `
+INSERT INTO subscription_plan_feature_values (subscription_plan_id, feature_id, value, created_at, updated_at)
+SELECT p.id, f.id, v.value, NOW(), NOW()
+FROM (VALUES
+  ${featureValueRows}
+) AS v(plan_code, feature_code, value)
+JOIN subscription_plans p ON p.code = v.plan_code
+JOIN subscription_plan_features f ON f.code = v.feature_code;
+`;
+  }
+
+  syncSql += `\nCOMMIT;\n`;
+
+  // Step 10 — Execute on remote with spinner
+  const spinner = ora('Syncing features to production...').start();
+
+  const execResult = spawnSync('ssh', [
+    `${vpsUser}@${vpsHost}`,
+    `cd ${vpsAppFolder}/infrastructure && docker compose -f docker-compose.yml -f docker-compose.prod.yml exec -T database sh -c 'psql -v ON_ERROR_STOP=1 -U $POSTGRES_USER $POSTGRES_DB'`
+  ], { input: syncSql, encoding: 'utf8' });
+
+  if (execResult.status !== 0) {
+    spinner.fail('Failed to sync features to production.');
+    if (execResult.stderr) {
+      console.error(chalk.gray(execResult.stderr));
+    }
+    process.exit(1);
+  }
+
+  spinner.succeed(chalk.green(`Synced ${features.length} features and ${featureValues.length} feature-plan values to production.`));
+  console.log();
+}
+
+module.exports = { deploySyncFeatures };

package/src/commands/deploy-up.js

@@ -105,8 +105,8 @@ async function deployUp() {
   const verifySpinner = ora('Checking service status...').start();
 
   try {
-    const { stdout: psOutput} = await execAsync(
-      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml ps"`,
+    const { stdout: psOutput } = await execAsync(
+      `ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml ps"`,
       { timeout: 30000 }
     );
 
@@ -114,6 +114,7 @@ async function deployUp() {
 
     console.log(chalk.gray('\n' + psOutput));
   } catch (error) {
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
     verifySpinner.warn('Could not verify services');
   }
 
@@ -138,7 +139,7 @@ async function deployUp() {
   console.log(chalk.gray('   Just push to GitHub - CI/CD will handle deployment automatically!\n'));
 
   console.log(chalk.white('3. Monitor services:'));
-  console.log(chalk.gray(`   Run: ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose logs -f"\n`));
+  console.log(chalk.gray(`   Run: ssh ${vpsUser}@${vpsHost} "cd ${vpsAppFolder}/infrastructure && docker-compose -f docker-compose.yml -f docker-compose.prod.yml logs -f"\n`));
 }
 
 module.exports = { deployUp };

package/src/commands/dev-add-user.js

@@ -0,0 +1,165 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const chalk = require('chalk');
+const bcrypt = require('bcryptjs');
+const { spawnSync } = require('child_process');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+
+const FIRST_NAMES = [
+  'Alice', 'Bob', 'Carol', 'David', 'Eve', 'Frank', 'Grace', 'Henry',
+  'Iris', 'Jack', 'Karen', 'Leo', 'Mia', 'Nathan', 'Olivia'
+];
+
+const LAST_NAMES = [
+  'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller',
+  'Davis', 'Wilson', 'Moore', 'Taylor', 'Anderson', 'Thomas', 'Jackson', 'White'
+];
+
+function randomElement(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function generateDummyUser() {
+  const firstName = randomElement(FIRST_NAMES);
+  const lastName = randomElement(LAST_NAMES);
+  const suffix = String(Math.floor(1000 + Math.random() * 9000));
+  const email = `${firstName.toLowerCase()}.${lastName.toLowerCase()}${suffix}@gmail.com`;
+  return { firstName, lastName, name: `${firstName} ${lastName}`, email, suffix };
+}
+
+function checkEmailExists(infrastructurePath, email) {
+  const composeArgs = [
+    'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+    'exec', '-T', 'database', 'sh', '-c', 'psql -U $POSTGRES_USER $POSTGRES_DB -t -c "SELECT COUNT(*) FROM users WHERE email = \'__EMAIL__\'"'
+      .replace('__EMAIL__', email.replace(/'/g, "''"))
+  ];
+
+  const result = spawnSync('docker', composeArgs, { cwd: infrastructurePath, encoding: 'utf8' });
+  if (result.status !== 0) return false;
+  const count = parseInt((result.stdout || '').trim(), 10);
+  return count > 0;
+}
+
+async function devAddUser() {
+  requireProject();
+
+  const infrastructurePath = path.join(process.cwd(), 'infrastructure');
+
+  if (!fs.existsSync(infrastructurePath)) {
+    console.error(chalk.red('\n❌ Error: infrastructure/ directory not found'));
+    console.log(chalk.gray('Make sure you are in the root of your LaunchFrame project.\n'));
+    process.exit(1);
+  }
+
+  // Check database container is running
+  const psResult = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'ps', '--status', 'running', '-q', 'database'
+    ],
+    { cwd: infrastructurePath, encoding: 'utf8' }
+  );
+
+  if (!psResult.stdout || psResult.stdout.trim() === '') {
+    console.error(chalk.red('\n❌ Database container is not running.'));
+    console.log(chalk.gray('Start local services first:'));
+    console.log(chalk.white('  launchframe docker:up\n'));
+    process.exit(1);
+  }
+
+  // Generate user with unique email (up to 5 attempts)
+  let user = null;
+  for (let attempt = 0; attempt < 5; attempt++) {
+    const candidate = generateDummyUser();
+    if (!checkEmailExists(infrastructurePath, candidate.email)) {
+      user = candidate;
+      break;
+    }
+  }
+
+  if (!user) {
+    console.error(chalk.red('\n❌ Could not generate a unique email after 5 attempts.'));
+    process.exit(1);
+  }
+
+  const config = getProjectConfig();
+  const isMultiTenant = config.variants?.tenancy === 'multi-tenant';
+
+  const passwordHash = await bcrypt.hash('test123', 10);
+  const accountId = crypto.randomUUID();
+
+  const projectTitle = `Demo Project`;
+  const projectSlug = `demo-project-${user.suffix}`;
+
+  const projectInsert = isMultiTenant ? `
+  INSERT INTO projects (user_id, title, slug, description, created_at, updated_at)
+  VALUES (
+    new_user_id,
+    '${projectTitle}',
+    '${projectSlug}',
+    'Auto-generated demo project',
+    NOW(),
+    NOW()
+  );` : '';
+
+  const sqlScript = `
+DO $$
+DECLARE
+  new_user_id INT;
+BEGIN
+  INSERT INTO users (email, name, role, email_verified, is_active, created_at, updated_at)
+  VALUES (
+    '${user.email.replace(/'/g, "''")}',
+    '${user.name.replace(/'/g, "''")}',
+    'business_user',
+    true,
+    true,
+    NOW(),
+    NOW()
+  )
+  RETURNING id INTO new_user_id;
+
+  INSERT INTO accounts (id, user_id, account_id, provider_id, password, created_at, updated_at)
+  VALUES (
+    '${accountId}',
+    new_user_id,
+    new_user_id::text,
+    'credential',
+    '${passwordHash.replace(/'/g, "''")}',
+    NOW(),
+    NOW()
+  );
+${projectInsert}
+END $$;
+`;
+
+  const execResult = spawnSync(
+    'docker',
+    [
+      'compose', '-f', 'docker-compose.yml', '-f', 'docker-compose.dev.yml',
+      'exec', '-T', 'database', 'sh', '-c', 'psql -v ON_ERROR_STOP=1 -U $POSTGRES_USER $POSTGRES_DB'
+    ],
+    { cwd: infrastructurePath, input: sqlScript, encoding: 'utf8' }
+  );
+
+  if (execResult.status !== 0) {
+    console.error(chalk.red('\n❌ Failed to insert user into database.'));
+    if (execResult.stderr) {
+      console.error(chalk.gray(execResult.stderr));
+    }
+    process.exit(1);
+  }
+
+  console.log(chalk.green('\n✅ User created!'));
+  console.log(chalk.gray(`   Name:     ${user.name}`));
+  console.log(chalk.gray(`   Email:    ${user.email}`));
+  console.log(chalk.gray(`   Password: test123`));
+  if (isMultiTenant) {
+    console.log(chalk.gray(`   Project:  ${projectTitle} (${projectSlug})`));
+  }
+  console.log();
+}
+
+module.exports = { devAddUser };

package/src/commands/dev-logo.js

@@ -0,0 +1,161 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { requireProject, getProjectConfig } = require('../utils/project-helpers');
+
+/**
+ * Render SVG to PNG buffer at a given size using @resvg/resvg-js
+ * @param {Buffer} svgBuffer - SVG file buffer
+ * @param {number} size - Width/height in pixels
+ * @returns {Buffer} PNG buffer
+ */
+function renderPng(Resvg, svgBuffer, size) {
+  const resvg = new Resvg(svgBuffer, {
+    fitTo: { mode: 'width', value: size },
+  });
+  const pngData = resvg.render();
+  return pngData.asPng();
+}
+
+/**
+ * Write a file, creating directories as needed
+ * @param {string} filePath - Absolute path to write
+ * @param {Buffer|string} data - File content
+ */
+function writeFile(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, data);
+  console.log(chalk.gray(`  ✓ ${filePath.replace(process.cwd() + '/', '')}`));
+}
+
+/**
+ * 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(svgPath) {
+  requireProject();
+
+  const cwd = process.cwd();
+  const logoPath = svgPath || path.join(cwd, 'logo.svg');
+
+  if (!fs.existsSync(logoPath)) {
+    console.error(chalk.red('\n❌ Error: logo.svg not found'));
+    console.log(chalk.gray('Place your logo.svg file in the project root:'));
+    console.log(chalk.white(`  ${cwd}/logo.svg`));
+    console.log();
+    console.log(chalk.gray('Then run:'));
+    console.log(chalk.white('  launchframe dev:logo\n'));
+    process.exit(1);
+  }
+
+  const config = getProjectConfig();
+  const hasCustomersPortal = (config.installedServices || []).includes('customers-portal');
+
+  // Lazy load heavy dependencies
+  const { Resvg } = require('@resvg/resvg-js');
+  const toIco = require('to-ico');
+
+  const svgBuffer = fs.readFileSync(logoPath);
+  const svgContent = svgBuffer.toString('utf8');
+
+  console.log(chalk.blue.bold('\nGenerating logo assets...\n'));
+
+  // ─── Website ─────────────────────────────────────────────────────────────
+  const websitePath = path.join(cwd, 'website');
+  if (!fs.existsSync(websitePath)) {
+    console.log(chalk.yellow('⚠ website not found — skipping'));
+  } else {
+    console.log(chalk.white('website/public/'));
+    const pub = path.join(websitePath, 'public');
+    const images = path.join(pub, 'images');
+
+    const png16 = renderPng(Resvg, svgBuffer, 16);
+    const png32 = renderPng(Resvg, svgBuffer, 32);
+    const png96 = renderPng(Resvg, svgBuffer, 96);
+    const png180 = renderPng(Resvg, svgBuffer, 180);
+    const png512 = renderPng(Resvg, svgBuffer, 512);
+    const icoBuffer = await toIco([png16, png32]);
+
+    writeFile(path.join(pub, 'favicon.ico'), icoBuffer);
+    writeFile(path.join(pub, 'favicon.svg'), svgContent);
+    writeFile(path.join(pub, 'favicon.png'), png32);
+    writeFile(path.join(pub, 'favicon-96x96.png'), png96);
+    writeFile(path.join(pub, 'apple-touch-icon.png'), png180);
+    writeFile(path.join(images, 'logo.svg'), svgContent);
+    writeFile(path.join(images, 'logo.png'), png512);
+  }
+
+  // ─── Admin Portal ─────────────────────────────────────────────────────────
+  const adminPath = path.join(cwd, 'admin-portal');
+  if (!fs.existsSync(adminPath)) {
+    console.log(chalk.yellow('⚠ admin-portal not found — skipping'));
+  } else {
+    console.log(chalk.white('\nadmin-portal/public/'));
+    const pub = path.join(adminPath, 'public');
+    const favicons = path.join(pub, 'favicons');
+    const srcAssets = path.join(adminPath, 'src', 'assets');
+
+    const png16 = renderPng(Resvg, svgBuffer, 16);
+    const png24 = renderPng(Resvg, svgBuffer, 24);
+    const png32 = renderPng(Resvg, svgBuffer, 32);
+    const png64 = renderPng(Resvg, svgBuffer, 64);
+    const png96 = renderPng(Resvg, svgBuffer, 96);
+    const png180 = renderPng(Resvg, svgBuffer, 180);
+    const png192 = renderPng(Resvg, svgBuffer, 192);
+    const png512 = renderPng(Resvg, svgBuffer, 512);
+    const icoBuffer = await toIco([png16, png32]);
+    const icoFavicons = await toIco([png16, png24, png32, png64]);
+
+    writeFile(path.join(pub, 'favicon.ico'), icoBuffer);
+    writeFile(path.join(pub, 'favicon.svg'), svgContent);
+    writeFile(path.join(pub, 'favicon.png'), png32);
+    writeFile(path.join(favicons, 'favicon.svg'), svgContent);
+    writeFile(path.join(favicons, 'favicon.ico'), icoFavicons);
+    writeFile(path.join(favicons, 'favicon-16x16.png'), png16);
+    writeFile(path.join(favicons, 'favicon-32x32.png'), png32);
+    writeFile(path.join(favicons, 'favicon-96x96.png'), png96);
+    writeFile(path.join(favicons, 'web-app-manifest-192x192.png'), png192);
+    writeFile(path.join(favicons, 'web-app-manifest-96x96.png'), png96);
+    writeFile(path.join(favicons, 'web-app-manifest-512x512.png'), png512);
+    writeFile(path.join(favicons, 'apple-touch-icon.png'), png180);
+    writeFile(path.join(pub, 'logo.svg'), svgContent);
+    writeFile(path.join(pub, 'logo.png'), png512);
+    writeFile(path.join(pub, 'logo192.png'), png192);
+    writeFile(path.join(pub, 'logo512.png'), png512);
+    writeFile(path.join(srcAssets, 'logo.svg'), svgContent);
+  }
+
+  // ─── Customers Portal (B2B2C only) ────────────────────────────────────────
+  if (hasCustomersPortal) {
+    const customersPath = path.join(cwd, 'customers-portal');
+    if (!fs.existsSync(customersPath)) {
+      console.log(chalk.yellow('\n⚠ customers-portal not found — skipping'));
+    } else {
+      console.log(chalk.white('\ncustomers-portal/public/'));
+      const pub = path.join(customersPath, 'public');
+      const favicons = path.join(pub, 'favicons');
+
+      const png16 = renderPng(Resvg, svgBuffer, 16);
+      const png32 = renderPng(Resvg, svgBuffer, 32);
+      const png96 = renderPng(Resvg, svgBuffer, 96);
+      const png180 = renderPng(Resvg, svgBuffer, 180);
+      const png512 = renderPng(Resvg, svgBuffer, 512);
+      const icoBuffer = await toIco([png16, png32]);
+
+      writeFile(path.join(pub, 'favicon.ico'), icoBuffer);
+      writeFile(path.join(pub, 'favicon.svg'), svgContent);
+      writeFile(path.join(pub, 'favicon.png'), png32);
+      writeFile(path.join(favicons, 'favicon.svg'), svgContent);
+      writeFile(path.join(favicons, 'favicon-16x16.png'), png16);
+      writeFile(path.join(favicons, 'favicon-32x32.png'), png32);
+      writeFile(path.join(favicons, 'favicon-96x96.png'), png96);
+      writeFile(path.join(favicons, 'apple-touch-icon.png'), png180);
+      writeFile(path.join(pub, 'logo.svg'), svgContent);
+      writeFile(path.join(pub, 'logo.png'), png512);
+    }
+  }
+
+  console.log(chalk.green('\n✅ Logo assets generated successfully!\n'));
+}
+
+module.exports = { devLogo };

package/src/commands/dev-npm-install.js

@@ -0,0 +1,33 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const { requireProject } = require('../utils/project-helpers');
+
+async function devNpmInstall(serviceName, packages = []) {
+  requireProject();
+
+  const servicePath = path.join(process.cwd(), serviceName);
+
+  if (!fs.existsSync(servicePath)) {
+    console.error(chalk.red(`\n❌ Error: directory "${serviceName}/" not found`));
+    process.exit(1);
+  }
+
+  const pkgList = packages.length ? packages.join(' ') : '';
+  const label = pkgList ? `Installing ${pkgList} in ${serviceName}` : `Running npm install in ${serviceName}`;
+  console.log(chalk.blue.bold(`\n📦 ${label}\n`));
+  console.log(chalk.gray('Using node:20-alpine to match Docker build environment...\n'));
+
+  const npmArgs = pkgList ? `npm install ${pkgList}` : 'npm install';
+  const cmd = `docker run --rm -v "${servicePath}":/app -w /app node:20-alpine ${npmArgs}`;
+  console.log(chalk.gray(`Running: ${cmd}\n`));
+
+  execSync(cmd, { stdio: 'inherit' });
+
+  console.log(chalk.green.bold(`\n✅ Done! package-lock.json updated with node:20-alpine.\n`));
+  console.log(chalk.white('Next: rebuild the service:'));
+  console.log(chalk.gray(`  launchframe docker:build ${serviceName}\n`));
+}
+
+module.exports = { devNpmInstall };