@launchframe/cli 0.1.11 → 1.0.0-beta.10

package/src/utils/docker-helper.js

@@ -43,7 +43,7 @@ async function loginToGHCR(githubOrg, ghcrToken) {
 
 /**
  * Build and push a Docker image
- * @param {string} serviceName - Service name (e.g., 'backend', 'admin-frontend')
+ * @param {string} serviceName - Service name (e.g., 'backend', 'admin-portal')
  * @param {string} contextDir - Docker build context directory
  * @param {string} registry - Registry URL (e.g., 'ghcr.io/myorg')
  * @param {string} projectName - Project name
@@ -111,57 +111,77 @@ function loadEnvFile(envFilePath) {
  * @param {string} projectName - Project name
  * @param {string} githubOrg - GitHub organization/username
  * @param {string} envFilePath - Path to .env.prod file
+ * @param {string[]} installedServices - List of installed services from .launchframe
  * @returns {Promise<void>}
  */
-async function buildFullAppImages(projectRoot, projectName, githubOrg, envFilePath) {
+async function buildFullAppImages(projectRoot, projectName, githubOrg, envFilePath, installedServices = []) {
   const registry = `ghcr.io/${githubOrg}`;
   const envVars = loadEnvFile(envFilePath);
 
   console.log(chalk.yellow('\n📦 Building production Docker images...\n'));
   console.log(chalk.gray('This may take 10-20 minutes depending on your system.\n'));
+  console.log(chalk.gray(`Services to build: ${installedServices.join(', ')}\n`));
+
+  // Build backend (always required)
+  if (installedServices.includes('backend')) {
+    await buildAndPushImage(
+      'backend',
+      path.join(projectRoot, 'backend'),
+      registry,
+      projectName
+    );
+  }
+
+  // Build admin-portal (always required)
+  if (installedServices.includes('admin-portal')) {
+    await buildAndPushImage(
+      'admin-portal',
+      path.join(projectRoot, 'admin-portal'),
+      registry,
+      projectName
+    );
+  }
+
+  // Build customers-portal (only if installed - B2B2C mode)
+  if (installedServices.includes('customers-portal')) {
+    await buildAndPushImage(
+      'customers-portal',
+      path.join(projectRoot, 'customers-portal'),
+      registry,
+      projectName
+    );
+  }
 
-  // Build backend
-  await buildAndPushImage(
-    'backend',
-    path.join(projectRoot, 'backend'),
-    registry,
-    projectName
-  );
-
-  // Build admin-frontend
-  await buildAndPushImage(
-    'admin-frontend',
-    path.join(projectRoot, 'admin-frontend'),
-    registry,
-    projectName
-  );
-
-  // Build customers-frontend
-  await buildAndPushImage(
-    'customers-frontend',
-    path.join(projectRoot, 'frontend'),
-    registry,
-    projectName
-  );
-
-  // Build website (requires build args)
-  const websiteBuildArgs = [
-    `APP_NAME=${envVars.APP_NAME || ''}`,
-    `DOCS_URL=${envVars.DOCS_URL || ''}`,
-    `CONTACT_EMAIL=${envVars.CONTACT_EMAIL || ''}`,
-    `CTA_LINK=${envVars.CTA_LINK || ''}`,
-    `LIVE_DEMO_URL=${envVars.LIVE_DEMO_URL || ''}`,
-    `MIXPANEL_PROJECT_TOKEN=${envVars.MIXPANEL_PROJECT_TOKEN || ''}`,
-    `GOOGLE_ANALYTICS_ID=${envVars.GOOGLE_ANALYTICS_ID || ''}`
-  ];
-
-  await buildAndPushImage(
-    'website',
-    path.join(projectRoot, 'website'),
-    registry,
-    projectName,
-    websiteBuildArgs
-  );
+  // Build website (always required)
+  if (installedServices.includes('website')) {
+    const websiteBuildArgs = [
+      `APP_NAME=${envVars.APP_NAME || ''}`,
+      `DOCS_URL=${envVars.DOCS_URL || ''}`,
+      `CONTACT_EMAIL=${envVars.CONTACT_EMAIL || ''}`,
+      `CTA_LINK=${envVars.CTA_LINK || ''}`,
+      `LIVE_DEMO_URL=${envVars.LIVE_DEMO_URL || ''}`,
+      `MIXPANEL_PROJECT_TOKEN=${envVars.MIXPANEL_PROJECT_TOKEN || ''}`,
+      `GOOGLE_ANALYTICS_ID=${envVars.GOOGLE_ANALYTICS_ID || ''}`
+    ];
+
+    await buildAndPushImage(
+      'website',
+      path.join(projectRoot, 'website'),
+      registry,
+      projectName,
+      websiteBuildArgs
+    );
+  }
+
+  // Build docs (optional service - VitePress documentation)
+  if (installedServices.includes('docs')) {
+    await buildAndPushImage(
+      'docs',
+      path.join(projectRoot, 'docs'),
+      registry,
+      projectName
+    );
+  }
 }
 
 /**
@@ -196,6 +216,8 @@ async function buildWaitlistImage(projectRoot, projectName, githubOrg) {
       `AIRTABLE_TABLE_NAME=${envVars.AIRTABLE_TABLE_NAME || 'Waitlist'}`,
       `NEXT_PUBLIC_PROJECT_NAME=${envVars.NEXT_PUBLIC_PROJECT_NAME || envVars.PROJECT_NAME || ''}`,
       `NEXT_PUBLIC_SITE_URL=${envVars.NEXT_PUBLIC_SITE_URL || ''}`,
+      `NEXT_PUBLIC_MIXPANEL_PROJECT_TOKEN=${envVars.NEXT_PUBLIC_MIXPANEL_PROJECT_TOKEN || ''}`,
+      `NEXT_PUBLIC_MIXPANEL_DATA_RESIDENCY=${envVars.NEXT_PUBLIC_MIXPANEL_DATA_RESIDENCY || ''}`,
       `PROJECT_NAME=${envVars.PROJECT_NAME || ''}`,
       `PRIMARY_DOMAIN=${envVars.PRIMARY_DOMAIN || ''}`
     ];

package/src/utils/github-access.js

@@ -0,0 +1,67 @@
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+/**
+ * Create a clickable terminal link using OSC 8 escape sequence
+ * Works in modern terminals (iTerm2, Hyper, Windows Terminal, VS Code, etc.)
+ * Falls back gracefully to plain text in unsupported terminals
+ * @param {string} text - Display text
+ * @param {string} url - Target URL
+ * @returns {string} Formatted link
+ */
+function makeClickable(text, url) {
+  return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+
+/**
+ * Check if user has SSH access to LaunchFrame services repository
+ * @returns {Promise<{hasAccess: boolean, error?: string}>}
+ */
+async function checkGitHubAccess() {
+  try {
+    // Test SSH access by checking if we can list remote refs
+    execSync(
+      'git ls-remote git@github.com:launchframe-dev/services.git HEAD',
+      { 
+        timeout: 15000,
+        stdio: 'pipe' // Don't show output
+      }
+    );
+    return { hasAccess: true };
+  } catch (error) {
+    return {
+      hasAccess: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Display message when user doesn't have access to services repository
+ * Guides them to either purchase or setup SSH keys
+ */
+function showAccessDeniedMessage() {
+  const purchaseUrl = 'https://buy.polar.sh/polar_cl_Zy4YqEwhoIEdUrAH8vHaWuZtwZuv306sYMnq118MbKi';
+  const docsUrl = 'https://docs.launchframe.dev/guide/quick-start#add-ssh-key-to-repo';
+  
+  console.log(chalk.red('\n❌ Cannot access LaunchFrame services repository\n'));
+  
+  console.log(chalk.white('This could mean:\n'));
+  console.log(chalk.gray('  1. You haven\'t purchased LaunchFrame yet'));
+  console.log(chalk.gray('  2. You purchased but haven\'t added your SSH key to the repo\n'));
+  
+  console.log(chalk.cyan('→ New customers:'));
+  console.log('  ' + chalk.blue.bold.underline(makeClickable('Purchase LaunchFrame', purchaseUrl)));
+  console.log('  ' + chalk.cyan(purchaseUrl + '\n'));
+  
+  console.log(chalk.cyan('→ Existing customers:'));
+  console.log('  ' + chalk.blue.bold.underline(makeClickable('Setup SSH key (docs)', docsUrl)));
+  console.log('  ' + chalk.cyan(docsUrl + '\n'));
+  
+  console.log(chalk.gray('After setup, run: launchframe init\n'));
+}
+
+module.exports = {
+  checkGitHubAccess,
+  showAccessDeniedMessage
+};

package/src/utils/project-helpers.js

@@ -7,7 +7,11 @@ const chalk = require('chalk');
  */
 function isLaunchFrameProject() {
   const markerPath = path.join(process.cwd(), '.launchframe');
-  return fs.existsSync(markerPath);
+  try {
+    return fs.existsSync(markerPath) && fs.statSync(markerPath).isFile();
+  } catch (error) {
+    return false;
+  }
 }
 
 /**
@@ -76,7 +80,7 @@ function addInstalledComponent(componentName) {
  * @returns {string|null} Primary domain
  */
 function getPrimaryDomain(config) {
-  return config.primaryDomain || null;
+  return config.deployment?.primaryDomain || null;
 }
 
 /**

package/src/utils/section-replacer.js

@@ -9,32 +9,46 @@ const fs = require('fs-extra');
 async function replaceSection(filePath, sectionName, newContent) {
   const content = await fs.readFile(filePath, 'utf8');
 
-  // Try both comment formats (// for regular comments, {/* */} for JSX)
-  const startMarkerRegular = `// ${sectionName}_START`;
-  const endMarkerRegular = `// ${sectionName}_END`;
+  // Try all comment formats (// for JS/TS, {/* */} for JSX, # for YAML/Shell)
+  const startMarkerSlash = `// ${sectionName}_START`;
+  const endMarkerSlash = `// ${sectionName}_END`;
   const startMarkerJSX = `{/* ${sectionName}_START */}`;
   const endMarkerJSX = `{/* ${sectionName}_END */}`;
+  const startMarkerHash = `# ${sectionName}_START`;
+  const endMarkerHash = `# ${sectionName}_END`;
 
-  let startIndex = content.indexOf(startMarkerRegular);
-  let endIndex = content.indexOf(endMarkerRegular);
-  let isJSX = false;
+  let startIndex = content.indexOf(startMarkerSlash);
+  let endIndex = content.indexOf(endMarkerSlash);
 
-  // If not found with regular comments, try JSX comments
+  // If not found with // comments, try JSX comments
   if (startIndex === -1 || endIndex === -1) {
     startIndex = content.indexOf(startMarkerJSX);
     endIndex = content.indexOf(endMarkerJSX);
-    isJSX = true;
+  }
+
+  // If not found with JSX comments, try # comments (YAML/Shell)
+  if (startIndex === -1 || endIndex === -1) {
+    startIndex = content.indexOf(startMarkerHash);
+    endIndex = content.indexOf(endMarkerHash);
   }
 
   if (startIndex === -1 || endIndex === -1) {
     throw new Error(`Section markers not found: ${sectionName} in ${filePath}`);
   }
 
+  // Find the start of the start marker line (beginning of line, not just the marker)
+  let lineStart = content.lastIndexOf('\n', startIndex - 1);
+  if (lineStart === -1) {
+    lineStart = 0; // Marker is on first line
+  } else {
+    lineStart += 1; // Move past the newline to the start of the line
+  }
+
   // Find the end of the end marker line
   const endLineEnd = content.indexOf('\n', endIndex);
 
-  // Construct new content - exclude both marker lines
-  const before = content.substring(0, startIndex);
+  // Construct new content - exclude both marker lines (including leading whitespace)
+  const before = content.substring(0, lineStart);
   const after = content.substring(endLineEnd + 1);
   const replaced = before + newContent + after;
 
@@ -50,16 +64,19 @@ async function replaceSection(filePath, sectionName, newContent) {
 async function hasSection(filePath, sectionName) {
   try {
     const content = await fs.readFile(filePath, 'utf8');
-    const startMarkerRegular = `// ${sectionName}_START`;
-    const endMarkerRegular = `// ${sectionName}_END`;
+    const startMarkerSlash = `// ${sectionName}_START`;
+    const endMarkerSlash = `// ${sectionName}_END`;
     const startMarkerJSX = `{/* ${sectionName}_START */}`;
     const endMarkerJSX = `{/* ${sectionName}_END */}`;
+    const startMarkerHash = `# ${sectionName}_START`;
+    const endMarkerHash = `# ${sectionName}_END`;
 
-    // Check both comment formats
-    const hasRegular = content.includes(startMarkerRegular) && content.includes(endMarkerRegular);
+    // Check all comment formats
+    const hasSlash = content.includes(startMarkerSlash) && content.includes(endMarkerSlash);
     const hasJSX = content.includes(startMarkerJSX) && content.includes(endMarkerJSX);
+    const hasHash = content.includes(startMarkerHash) && content.includes(endMarkerHash);
 
-    return hasRegular || hasJSX;
+    return hasSlash || hasJSX || hasHash;
   } catch (error) {
     return false;
   }

package/src/utils/service-cache.js

@@ -0,0 +1,274 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+const SERVICES_REPO = 'git@github.com:launchframe-dev/services.git';
+const BRANCH = 'main';
+
+/**
+ * Get the cache directory path
+ * Works cross-platform (Linux, Mac, Windows)
+ * @returns {string} Cache directory path
+ */
+function getCacheDir() {
+  const homeDir = os.homedir();
+  // Use same path structure on all platforms
+  // Windows: C:\Users\username\.launchframe\cache\services
+  // Mac/Linux: /home/username/.launchframe/cache/services
+  return path.join(homeDir, '.launchframe', 'cache', 'services');
+}
+
+/**
+ * Check if cache exists and is valid
+ * @returns {boolean} True if cache exists
+ */
+async function cacheExists() {
+  const cacheDir = getCacheDir();
+  const gitDir = path.join(cacheDir, '.git');
+  return await fs.pathExists(gitDir);
+}
+
+/**
+ * Initialize cache with sparse checkout
+ * Clones only the repository structure, no services yet
+ * @returns {Promise<void>}
+ */
+async function initializeCache() {
+  const cacheDir = getCacheDir();
+
+  console.log(chalk.blue('🔄 Initializing services cache...'));
+
+  try {
+    // Ensure parent directory exists
+    await fs.ensureDir(path.dirname(cacheDir));
+
+    // Sparse clone (only root files, no services)
+    execSync(
+      `git clone --sparse --depth 1 --branch ${BRANCH} ${SERVICES_REPO} "${cacheDir}"`,
+      {
+        stdio: 'pipe', // Hide output
+        timeout: 60000 // 1 minute timeout
+      }
+    );
+
+    // Configure sparse checkout (starts with empty set)
+    execSync('git sparse-checkout init --cone', {
+      cwd: cacheDir,
+      stdio: 'pipe'
+    });
+
+    console.log(chalk.green('✓ Cache initialized'));
+  } catch (error) {
+    // Clean up partial clone on failure
+    await fs.remove(cacheDir);
+    throw new Error(`Failed to initialize cache: ${error.message}`);
+  }
+}
+
+/**
+ * Update cache to latest version from main branch
+ * Requires internet connection
+ * @returns {Promise<void>}
+ */
+async function updateCache() {
+  const cacheDir = getCacheDir();
+
+  console.log(chalk.blue('🔄 Updating service cache...'));
+
+  try {
+    execSync('git pull origin main', {
+      cwd: cacheDir,
+      stdio: 'pipe',
+      timeout: 30000 // 30 seconds
+    });
+
+    console.log(chalk.green('✓ Cache updated'));
+  } catch (error) {
+    throw new Error(`Failed to update cache: ${error.message}`);
+  }
+}
+
+/**
+ * Expand sparse checkout to include specific services
+ * @param {string[]} serviceNames - Array of services names to expand
+ * @returns {Promise<void>}
+ */
+async function expandServices(serviceNames) {
+  const cacheDir = getCacheDir();
+
+  console.log(chalk.blue(`📦 Loading services: ${serviceNames.join(', ')}...`));
+
+  try {
+    // Get current sparse checkout list
+    let currentServices = [];
+    try {
+      const output = execSync('git sparse-checkout list', {
+        cwd: cacheDir,
+        stdio: 'pipe',
+        encoding: 'utf8'
+      });
+      currentServices = output.trim().split('\n').filter(Boolean);
+    } catch (error) {
+      // No services yet, that's fine
+    }
+
+    // Add new services to the list
+    const allServices = [...new Set([...currentServices, ...serviceNames])];
+
+    // Set sparse checkout to include all services
+    execSync(`git sparse-checkout set ${allServices.join(' ')}`, {
+      cwd: cacheDir,
+      stdio: 'pipe',
+      timeout: 60000 // 1 minute (may need to download files)
+    });
+
+    console.log(chalk.green('✓ Services loaded'));
+  } catch (error) {
+    throw new Error(`Failed to expand services: ${error.message}`);
+  }
+}
+
+/**
+ * Get path to a specific service in the cache
+ * @param {string} serviceName - Service name (e.g., 'backend', 'admin-portal')
+ * @returns {string} Absolute path to service
+ */
+function getServicePath(serviceName) {
+  const cacheDir = getCacheDir();
+  return path.join(cacheDir, serviceName);
+}
+
+/**
+ * Get cache root path
+ * @returns {string} Absolute path to cache root
+ */
+function getCachePath() {
+  return getCacheDir();
+}
+
+/**
+ * Clear the entire service cache
+ * Useful for troubleshooting or forcing fresh download
+ * @returns {Promise<void>}
+ */
+async function clearCache() {
+  const cacheDir = getCacheDir();
+
+  if (await fs.pathExists(cacheDir)) {
+    await fs.remove(cacheDir);
+    console.log(chalk.green('✓ Cache cleared'));
+  } else {
+    console.log(chalk.gray('Cache is already empty'));
+  }
+}
+
+/**
+ * Get cache information (size, last update, services)
+ * @returns {Promise<{exists: boolean, path: string, size?: number, services?: string[], lastUpdate?: Date}>}
+ */
+async function getCacheInfo() {
+  const cacheDir = getCacheDir();
+  const info = {
+    exists: false,
+    path: cacheDir
+  };
+
+  if (!(await cacheExists())) {
+    return info;
+  }
+
+  info.exists = true;
+
+  try {
+    // Get cache size (du command works on Unix/Mac, different on Windows)
+    if (process.platform === 'win32') {
+      // Windows: use powershell to get size
+      const output = execSync(
+        `powershell -command "(Get-ChildItem -Path '${cacheDir}' -Recurse | Measure-Object -Property Length -Sum).Sum"`,
+        { encoding: 'utf8', stdio: 'pipe' }
+      );
+      info.size = parseInt(output.trim());
+    } else {
+      // Unix/Mac: use du
+      const output = execSync(`du -sb "${cacheDir}"`, {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      });
+      info.size = parseInt(output.split('\t')[0]);
+    }
+  } catch (error) {
+    // Size calculation failed, not critical
+  }
+
+  try {
+    // Get list of expanded services
+    const output = execSync('git sparse-checkout list', {
+      cwd: cacheDir,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    info.services = output.trim().split('\n').filter(Boolean);
+  } catch (error) {
+    info.services = [];
+  }
+
+  try {
+    // Get last update time from git log
+    const output = execSync('git log -1 --format=%cd --date=iso', {
+      cwd: cacheDir,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    info.lastUpdate = new Date(output.trim());
+  } catch (error) {
+    // Last update time failed, not critical
+  }
+
+  return info;
+}
+
+/**
+ * Ensure cache is ready (initialize if needed, update if exists)
+ * This is the main entry point for cache management
+ * @param {string[]} requiredServices - Services needed for the operation
+ * @returns {Promise<string>} Path to cache root
+ */
+async function ensureCacheReady(requiredServices) {
+  try {
+    if (!(await cacheExists())) {
+      // Cache doesn't exist, initialize it
+      await initializeCache();
+    } else {
+      // Cache exists, update it
+      await updateCache();
+    }
+
+    // Expand sparse checkout to include required services
+    await expandServices(requiredServices);
+
+    return getCachePath();
+  } catch (error) {
+    // If we fail and it's a network error, provide helpful message
+    if (error.message.includes('Connection') || error.message.includes('timed out')) {
+      throw new Error(
+        'Cannot connect to GitHub. Please check your internet connection and try again.'
+      );
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  getCacheDir,
+  cacheExists,
+  initializeCache,
+  updateCache,
+  expandServices,
+  getServicePath,
+  getCachePath,
+  clearCache,
+  getCacheInfo,
+  ensureCacheReady
+};

package/src/utils/variable-replacer.js

@@ -55,7 +55,10 @@ function escapeRegex(string) {
  */
 async function replaceVariablesInFile(filePath, variables) {
   try {
-    let content = await fs.readFile(filePath, 'utf8');
+    // Read file content - preserve line endings for shell scripts
+    // Use binary mode to avoid Node.js line ending normalization on Windows
+    const buffer = await fs.readFile(filePath);
+    let content = buffer.toString('utf8');
     let modified = false;
 
     // Replace each variable using regex with negative lookbehind
@@ -74,8 +77,10 @@ async function replaceVariablesInFile(filePath, variables) {
     }
 
     // Only write if changes were made
+    // Write as Buffer to preserve original line endings
     if (modified) {
-      await fs.writeFile(filePath, content, 'utf8');
+      const outputBuffer = Buffer.from(content, 'utf8');
+      await fs.writeFile(filePath, outputBuffer);
     }
 
     return modified;

package/src/utils/variant-processor.js

@@ -44,7 +44,7 @@ async function processServiceVariant(
   // Step 1: Copy base template (minimal - B2B + single-tenant)
   console.log(`  📁 Copying base template from ${serviceConfig.base}`);
   await copyDirectory(basePath, destination, {
-    exclude: ['node_modules', '.git', 'dist', '.env', 'templates']
+    exclude: ['node_modules', '.git', 'dist', '.env']
   });
 
   // Step 2: Determine which variants to apply
@@ -143,29 +143,41 @@ async function cleanupSectionMarkers(serviceName, serviceConfig, appliedVariants
       let content = await fs.readFile(targetFilePath, 'utf-8');
       let modified = false;
 
-      // Remove each unused section marker
+      // Remove each unused section marker (keep content, remove only marker comments)
       for (const sectionName of sectionNames) {
-        // Try both comment formats
-        const regularPattern = new RegExp(
-          `\\/\\/ ${sectionName}_START\\n[\\s\\S]*?\\/\\/ ${sectionName}_END\\n?`,
-          'g'
+        // Try all comment formats (// for JS/TS, {/* */} for JSX, # for YAML/Shell)
+        // Capture: START marker, content, END marker - replace with just content
+        // Include leading whitespace before markers to prevent indentation issues
+        const slashPattern = new RegExp(
+          `^[ \\t]*\\/\\/ ${sectionName}_START\\n([\\s\\S]*?)^[ \\t]*\\/\\/ ${sectionName}_END\\n?`,
+          'gm'
         );
         const jsxPattern = new RegExp(
-          `\\{\\/\\* ${sectionName}_START \\*\\/\\}\\n[\\s\\S]*?\\{\\/\\* ${sectionName}_END \\*\\/\\}\\n?`,
-          'g'
+          `^[ \\t]*\\{\\/\\* ${sectionName}_START \\*\\/\\}\\n([\\s\\S]*?)^[ \\t]*\\{\\/\\* ${sectionName}_END \\*\\/\\}\\n?`,
+          'gm'
+        );
+        const hashPattern = new RegExp(
+          `^[ \\t]*# ${sectionName}_START\\n([\\s\\S]*?)^[ \\t]*# ${sectionName}_END\\n?`,
+          'gm'
         );
 
-        const beforeRegular = content;
-        content = content.replace(regularPattern, '');
-        if (content !== beforeRegular) {
+        const beforeSlash = content;
+        content = content.replace(slashPattern, '$1');
+        if (content !== beforeSlash) {
           modified = true;
         }
 
         const beforeJsx = content;
-        content = content.replace(jsxPattern, '');
+        content = content.replace(jsxPattern, '$1');
         if (content !== beforeJsx) {
           modified = true;
         }
+
+        const beforeHash = content;
+        content = content.replace(hashPattern, '$1');
+        if (content !== beforeHash) {
+          modified = true;
+        }
       }
 
       if (modified) {