underpost 2.95.3 → 2.96.0

package/src/cli/index.js

@@ -172,59 +172,7 @@ program
   .option('--dev', 'Sets the development cli context')
 
   .description(`Manages static build of page, bundles, and documentation with comprehensive customization options.`)
-  .action((options) => {
-    // Handle config template generation
-    if (options.generateConfig) {
-      const configPath = typeof options.generateConfig === 'string' ? options.generateConfig : './static-config.json';
-      return UnderpostStatic.API.generateConfigTemplate(configPath);
-    }
-
-    // Parse comma-separated options
-    if (options.keywords) {
-      options.keywords = options.keywords.split(',').map((k) => k.trim());
-    }
-    if (options.headScripts) {
-      options.scripts = options.scripts || {};
-      options.scripts.head = options.headScripts.split(',').map((s) => ({ src: s.trim() }));
-    }
-    if (options.bodyScripts) {
-      options.scripts = options.scripts || {};
-      options.scripts.body = options.bodyScripts.split(',').map((s) => ({ src: s.trim() }));
-    }
-    if (options.styles) {
-      options.styles = options.styles.split(',').map((s) => ({ href: s.trim() }));
-    }
-    if (options.headComponents) {
-      options.headComponents = options.headComponents.split(',').map((c) => c.trim());
-    }
-    if (options.bodyComponents) {
-      options.bodyComponents = options.bodyComponents.split(',').map((c) => c.trim());
-    }
-
-    // Build metadata object from individual options
-    options.metadata = {
-      ...(options.title && { title: options.title }),
-      ...(options.description && { description: options.description }),
-      ...(options.keywords && { keywords: options.keywords }),
-      ...(options.author && { author: options.author }),
-      ...(options.themeColor && { themeColor: options.themeColor }),
-      ...(options.canonicalUrl && { canonicalURL: options.canonicalUrl }),
-      ...(options.thumbnail && { thumbnail: options.thumbnail }),
-      ...(options.locale && { locale: options.locale }),
-      ...(options.siteName && { siteName: options.siteName }),
-    };
-
-    // Build icons object
-    if (options.favicon || options.appleTouchIcon || options.manifest) {
-      options.icons = {
-        ...(options.favicon && { favicon: options.favicon }),
-        ...(options.appleTouchIcon && { appleTouchIcon: options.appleTouchIcon }),
-        ...(options.manifest && { manifest: options.manifest }),
-      };
-    }
-
-    return UnderpostStatic.API.callback(options);
-  });
+  .action(UnderpostStatic.API.callback);
 
 // 'config' command: Manage Underpost configurations
 program
@@ -233,6 +181,7 @@ program
   .argument('[key]', 'Optional: The specific configuration key to manage.')
   .argument('[value]', 'Optional: The value to set for the configuration key.')
   .option('--plain', 'Prints the configuration value in plain text.')
+  .option('--filter <keyword>', 'Filters the list by matching key or value (only for list operation).')
   .description(`Manages Underpost configurations using various operators.`)
   .action((...args) => Underpost.env[args[0]](args[1], args[2], args[3]));
 
@@ -417,8 +366,6 @@ program
     '--pod-name <pod-name>',
     'Comma-separated list of pod names or patterns (supports wildcards like "mariadb-*").',
   )
-  .option('--node-name <node-name>', 'Comma-separated list of node names to filter pods by their node placement.')
-  .option('--label-selector <selector>', 'Kubernetes label selector for filtering pods (e.g., "app=mariadb").')
   .option('--all-pods', 'Target all matching pods instead of just the first one.')
   .option('--primary-pod', 'Automatically detect and use MongoDB primary pod (MongoDB only).')
   .option('--stats', 'Display database statistics (collection/table names with document/row counts).')
@@ -479,9 +426,9 @@ program
       ', ',
     )}. Defaults to all available jobs.`,
   )
-  .option('--itc', 'Executes cron jobs within the container execution context.')
-  .option('--init', 'Initializes cron jobs for the default deployment ID.')
+  .option('--init-pm2-cronjobs', 'Initializes PM2 cron jobs from configuration for the specified deployment IDs.')
   .option('--git', 'Uploads cron job configurations to GitHub.')
+  .option('--update-package-scripts', 'Updates package.json start scripts for each deploy-id configuration.')
   .description('Manages cron jobs, including initialization, execution, and configuration updates.')
   .action(Underpost.cron.callback);
 
@@ -664,13 +611,26 @@ program
   .option('--control-server-uninstall', 'Uninstalls the baremetal control server.')
   .option('--control-server-db-install', 'Installs up the database for the baremetal control server.')
   .option('--control-server-db-uninstall', 'Uninstalls the database for the baremetal control server.')
+  .option('--install-packer', 'Installs Packer CLI.')
+  .option(
+    '--packer-maas-image-template <template-path>',
+    'Creates a new image folder from canonical/packer-maas template path (requires workflow-id).',
+  )
+  .option('--packer-workflow-id <workflow-id>', 'Specifies the workflow ID for Packer MAAS image operations.')
+  .option(
+    '--packer-maas-image-build',
+    'Builds a MAAS image using Packer for the workflow specified by --packer-workflow-id.',
+  )
+  .option(
+    '--packer-maas-image-upload',
+    'Uploads an existing MAAS image artifact without rebuilding for the workflow specified by --packer-workflow-id.',
+  )
   .option('--commission', 'Init workflow for commissioning a physical machine.')
   .option('--nfs-build', 'Builds an NFS root filesystem for a workflow id config architecture using QEMU emulation.')
   .option('--nfs-mount', 'Mounts the NFS root filesystem for a workflow id config architecture.')
   .option('--nfs-unmount', 'Unmounts the NFS root filesystem for a workflow id config architecture.')
   .option('--nfs-sh', 'Copies QEMU emulation root entrypoint shell command to the clipboard.')
   .option('--cloud-init-update', 'Updates cloud init for a workflow id config architecture.')
-  .option('--cloud-init-reset', 'Resets cloud init for a workflow id config architecture.')
   .option('--logs <log-id>', 'Displays logs for log id: dhcp, cloud, machine, cloud-config.')
   .option('--dev', 'Sets the development context environment for baremetal operations.')
   .option('--ls', 'Lists available boot resources and machines.')

package/src/cli/repository.js

@@ -587,6 +587,184 @@ Prevent build private config repo.`,
       fs.writeFileSync(targetConfPath, confRawPaths.join(sepRender), 'utf8');
       shellExec(`prettier --write ${targetConfPath}`);
     },
+
+    /**
+     * Cleans the specified paths in the repository by resetting, checking out, and cleaning untracked files.
+     * @param {object} [options={ paths: [''] }] - The options for cleaning.
+     * @param {string[]} [options.paths=['']] - The paths to clean.
+     * @memberof UnderpostRepository
+     */
+    clean(options = { paths: [''] }) {
+      for (const path of options.paths) {
+        shellExec(`cd ${path} && git reset`, { silent: true });
+        shellExec(`cd ${path} && git checkout .`, { silent: true });
+        shellExec(`cd ${path} && git clean -f -d`, { silent: true });
+      }
+    },
+
+    /**
+     * Copies files recursively from a Git repository URL directory path.
+     * @param {object} options - Configuration options for copying files.
+     * @param {string} options.gitUrl - The GitHub repository URL (e.g., 'https://github.com/canonical/packer-maas').
+     * @param {string} options.directoryPath - The directory path within the repository to copy (e.g., 'rocky-9').
+     * @param {string} options.targetPath - The local target path where files should be copied.
+     * @param {string} [options.branch='main'] - The git branch to use (default: 'main').
+     * @param {boolean} [options.overwrite=false] - Whether to overwrite existing target directory.
+     * @returns {Promise<object>} A promise that resolves with copied files information.
+     * @memberof UnderpostRepository
+     */
+    async copyGitUrlDirectoryRecursive(options) {
+      const { gitUrl, directoryPath, targetPath, branch = 'main', overwrite = false } = options;
+
+      // Validate inputs
+      if (!gitUrl) {
+        throw new Error('gitUrl is required');
+      }
+      if (!directoryPath) {
+        throw new Error('directoryPath is required');
+      }
+      if (!targetPath) {
+        throw new Error('targetPath is required');
+      }
+
+      // Parse GitHub URL to extract owner and repo
+      const urlMatch = gitUrl.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
+      if (!urlMatch) {
+        throw new Error(`Invalid GitHub URL: ${gitUrl}`);
+      }
+      const [, owner, repo] = urlMatch;
+
+      logger.info(`Copying from ${owner}/${repo}/${directoryPath} to ${targetPath}`);
+
+      // Check if target directory exists
+      if (fs.existsSync(targetPath) && !overwrite) {
+        throw new Error(`Target directory already exists: ${targetPath}. Use overwrite option to replace.`);
+      }
+
+      // Create target directory
+      fs.mkdirSync(targetPath, { recursive: true });
+
+      // GitHub API base URL
+      const githubApiBase = 'https://api.github.com/repos';
+      const apiUrl = `${githubApiBase}/${owner}/${repo}/contents/${directoryPath}`;
+
+      logger.info(`Fetching directory contents from: ${apiUrl}`);
+
+      try {
+        // Fetch directory contents recursively
+        const copiedFiles = await this._fetchAndCopyGitHubDirectory({
+          apiUrl,
+          targetPath,
+          basePath: directoryPath,
+          branch,
+        });
+
+        logger.info(`Successfully copied ${copiedFiles.length} files to ${targetPath}`);
+
+        return {
+          success: true,
+          filesCount: copiedFiles.length,
+          files: copiedFiles,
+          targetPath,
+        };
+      } catch (error) {
+        // Clean up on error
+        if (fs.existsSync(targetPath)) {
+          fs.removeSync(targetPath);
+          logger.warn(`Cleaned up target directory after error: ${targetPath}`);
+        }
+        throw new Error(`Failed to copy directory: ${error.message}`);
+      }
+    },
+
+    /**
+     * Internal method to recursively fetch and copy files from GitHub API.
+     * @private
+     * @param {object} options - Fetch options.
+     * @param {string} options.apiUrl - The GitHub API URL.
+     * @param {string} options.targetPath - The local target path.
+     * @param {string} options.basePath - The base path in the repository.
+     * @param {string} options.branch - The git branch.
+     * @returns {Promise<array>} Array of copied file paths.
+     * @memberof UnderpostRepository
+     */
+    async _fetchAndCopyGitHubDirectory(options) {
+      const { apiUrl, targetPath, basePath, branch } = options;
+      const copiedFiles = [];
+
+      const response = await fetch(apiUrl, {
+        headers: {
+          Accept: 'application/vnd.github.v3+json',
+          'User-Agent': 'underpost-cli',
+        },
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text();
+        logger.error(`GitHub API request failed for: ${apiUrl}`);
+        logger.error(`Status: ${response.status} ${response.statusText}`);
+        logger.error(`Response: ${errorBody}`);
+        throw new Error(`GitHub API request failed: ${response.status} ${response.statusText} - ${errorBody}`);
+      }
+
+      const contents = await response.json();
+
+      if (!Array.isArray(contents)) {
+        logger.error(`Expected directory but got: ${typeof contents}`);
+        logger.error(`API URL: ${apiUrl}`);
+        logger.error(`Response keys: ${Object.keys(contents).join(', ')}`);
+        if (contents.message) {
+          logger.error(`GitHub message: ${contents.message}`);
+        }
+        throw new Error(
+          `Path is not a directory: ${basePath}. Response: ${JSON.stringify(contents).substring(0, 200)}`,
+        );
+      }
+
+      logger.info(`Found ${contents.length} items in directory: ${basePath}`);
+
+      // Process each item in the directory
+      for (const item of contents) {
+        const itemTargetPath = `${targetPath}/${item.name}`;
+
+        if (item.type === 'file') {
+          logger.info(`Downloading file: ${item.path}`);
+
+          // Download file content
+          const fileResponse = await fetch(item.download_url);
+          if (!fileResponse.ok) {
+            logger.error(`Failed to download: ${item.download_url}`);
+            throw new Error(`Failed to download file: ${item.path} (${fileResponse.status})`);
+          }
+
+          const fileContent = await fileResponse.text();
+          fs.writeFileSync(itemTargetPath, fileContent);
+
+          logger.info(`✓ Saved: ${itemTargetPath}`);
+          copiedFiles.push(itemTargetPath);
+        } else if (item.type === 'dir') {
+          logger.info(`📁 Processing directory: ${item.path}`);
+
+          // Create subdirectory
+          fs.mkdirSync(itemTargetPath, { recursive: true });
+
+          // Recursively process subdirectory
+          const subFiles = await this._fetchAndCopyGitHubDirectory({
+            apiUrl: item.url,
+            targetPath: itemTargetPath,
+            basePath: item.path,
+            branch,
+          });
+
+          copiedFiles.push(...subFiles);
+          logger.info(`✓ Completed directory: ${item.path} (${subFiles.length} files)`);
+        } else {
+          logger.warn(`Skipping unknown item type '${item.type}': ${item.path}`);
+        }
+      }
+
+      return copiedFiles;
+    },
   };
 }
 

package/src/cli/run.js

@@ -446,8 +446,7 @@ class UnderpostRun {
      * @memberof UnderpostRun
      */
     clean: (path = '', options = UnderpostRun.DEFAULT_OPTION) => {
-      shellCd(path ? path : `/home/dd/engine`);
-      shellExec(`node bin/deploy clean-core-repo`);
+      Underpost.repo.clean({ paths: path ? path.split(',') : ['/home/dd/engine', '/home/dd/engine/engine-private'] });
     },
     /**
      * @method pull
@@ -1187,7 +1186,7 @@ EOF
       }
       await timer(5000);
       for (const deployId of deployList) {
-        shellExec(`${baseCommand} db ${deployId} --import --git`);
+        shellExec(`${baseCommand} db ${deployId} --import --git --drop --preserveUUID --primary-pod`);
       }
       await timer(5000);
       shellExec(`${baseCommand} cluster${baseClusterCommand} --${clusterType} --pull-image --valkey`);

package/src/cli/static.js

@@ -2,55 +2,6 @@
  * Static site generation module with enhanced customization capabilities
  * @module src/cli/static.js
  * @namespace UnderpostStatic
- *
- * @example
- * // Basic usage - generate a simple page
- * import UnderpostStatic from './static.js';
- *
- * await UnderpostStatic.API.callback({
- *   page: './src/client/ssr/body/DefaultSplashScreen.js',
- *   title: 'My App',
- *   outputPath: './dist/index.html'
- * });
- *
- * @example
- * // Advanced usage - full customization
- * await UnderpostStatic.API.callback({
- *   page: './src/client/ssr/body/CustomPage.js',
- *   outputPath: './dist/custom.html',
- *   metadata: {
- *     title: 'My Custom Page',
- *     description: 'A fully customized static page',
- *     keywords: ['static', 'generator', 'custom'],
- *     author: 'John Doe',
- *     themeColor: '#007bff',
- *     canonicalURL: 'https://example.com/custom',
- *     thumbnail: 'https://example.com/thumb.png'
- *   },
- *   scripts: {
- *     head: [
- *       { src: '/vendor/library.js', async: true },
- *       { content: 'console.log("Inline script");', type: 'module' }
- *     ],
- *     body: [
- *       { src: '/app.js', defer: true }
- *     ]
- *   },
- *   styles: [
- *     { href: '/custom.css' },
- *     { content: 'body { margin: 0; }' }
- *   ],
- *   headComponents: [
- *     './src/client/ssr/head/Seo.js',
- *     './src/client/ssr/head/Pwa.js'
- *   ],
- *   icons: {
- *     favicon: '/custom-favicon.ico',
- *     appleTouchIcon: '/apple-touch-icon.png'
- *   },
- *   env: 'production',
- *   minify: true
- * });
  */
 
 import fs from 'fs-extra';
@@ -140,6 +91,31 @@ const logger = loggerFactory(import.meta);
  * @property {Object} [microdata=[]] - Structured data (JSON-LD)
  */
 
+const DefaultStaticGenerationOptions = {
+  page: '',
+  title: '',
+  outputPath: '',
+  deployId: '',
+  buildHost: '',
+  buildPath: '/',
+  env: 'production',
+  build: false,
+  dev: false,
+  minify: true,
+  metadata: {},
+  scripts: {},
+  styles: [],
+  headComponents: [],
+  bodyComponents: [],
+  icons: {},
+  customPayload: {},
+  templateHelpers: {},
+  configFile: '',
+  lang: 'en',
+  dir: 'ltr',
+  microdata: [],
+};
+
 /**
  * Template helper functions for common SSR patterns
  * @namespace TemplateHelpers
@@ -150,19 +126,6 @@ const TemplateHelpers = {
    * @param {ScriptOptions} options - Script options
    * @returns {string} HTML script tag
    * @memberof TemplateHelpers
-   *
-   * @example
-   * // External script with async
-   * TemplateHelpers.createScriptTag({ src: '/app.js', async: true })
-   * // Returns: <script async src="/app.js"></script>
-   *
-   * @example
-   * // Inline module script
-   * TemplateHelpers.createScriptTag({
-   *   content: 'console.log("Hello");',
-   *   type: 'module'
-   * })
-   * // Returns: <script type="module">console.log("Hello");</script>
    */
   createScriptTag(options) {
     const attrs = [];
@@ -194,16 +157,6 @@ const TemplateHelpers = {
    * @param {StyleOptions} options - Style options
    * @returns {string} HTML link or style tag
    * @memberof TemplateHelpers
-   *
-   * @example
-   * // External stylesheet
-   * TemplateHelpers.createStyleTag({ href: '/styles.css' })
-   * // Returns: <link rel="stylesheet" href="/styles.css" media="all">
-   *
-   * @example
-   * // Inline styles
-   * TemplateHelpers.createStyleTag({ content: 'body { margin: 0; }' })
-   * // Returns: <style>body { margin: 0; }</style>
    */
   createStyleTag(options) {
     if (options.content) {
@@ -224,13 +177,6 @@ const TemplateHelpers = {
    * @param {IconOptions} icons - Icon options
    * @returns {string} HTML icon link tags
    * @memberof TemplateHelpers
-   *
-   * @example
-   * TemplateHelpers.createIconTags({
-   *   favicon: '/favicon.ico',
-   *   appleTouchIcon: '/apple-touch-icon.png',
-   *   manifest: '/manifest.json'
-   * })
    */
   createIconTags(icons) {
     const tags = [];
@@ -261,13 +207,6 @@ const TemplateHelpers = {
    * @param {MetadataOptions} metadata - Metadata options
    * @returns {string} HTML meta tags
    * @memberof TemplateHelpers
-   *
-   * @example
-   * TemplateHelpers.createMetaTags({
-   *   description: 'My page description',
-   *   keywords: ['web', 'app'],
-   *   author: 'John Doe'
-   * })
    */
   createMetaTags(metadata) {
     const tags = [];
@@ -329,16 +268,6 @@ const TemplateHelpers = {
    * @param {Object[]} microdata - Array of structured data objects
    * @returns {string} HTML script tags with JSON-LD
    * @memberof TemplateHelpers
-   *
-   * @example
-   * TemplateHelpers.createMicrodataTags([
-   *   {
-   *     '@context': 'https://schema.org',
-   *     '@type': 'WebSite',
-   *     'name': 'My Site',
-   *     'url': 'https://example.com'
-   *   }
-   * ])
    */
   createMicrodataTags(microdata) {
     if (!microdata || !Array.isArray(microdata) || microdata.length === 0) {
@@ -410,19 +339,6 @@ const ConfigLoader = {
    * @param {string} configPath - Path to config file
    * @returns {Object} Configuration object
    * @memberof ConfigLoader
-   *
-   * @example
-   * // static-config.json
-   * {
-   *   "metadata": {
-   *     "title": "My App",
-   *     "description": "My application description"
-   *   },
-   *   "env": "production"
-   * }
-   *
-   * // Usage
-   * const config = ConfigLoader.load('./static-config.json');
    */
   load(configPath) {
     try {
@@ -466,90 +382,83 @@ class UnderpostStatic {
      * Generate static HTML file with enhanced customization options
      *
      * @param {StaticGenerationOptions} options - Options for static generation
+     * @param {string} [options.page] - Path to the SSR component to render
+     * @param {string} [options.title] - Page title (deprecated: use metadata.title)
+     * @param {string} [options.outputPath] - Output file path
+     * @param {string} [options.deployId] - Deployment identifier
+     * @param {string} [options.buildHost] - Build host URL
+     * @param {string} [options.buildPath='/'] - Build path
+     * @param {string} [options.env='production'] - Environment (development/production)
+     * @param {boolean} [options.build=false] - Whether to trigger build
+     * @param {boolean} [options.minify=true] - Minify HTML output
+     * @param {MetadataOptions} [options.metadata={}] - Comprehensive metadata options
+     * @param {Object} [options.scripts={}] - Script injection options
+     * @param {ScriptOptions[]} [options.scripts.head=[]] - Scripts for
+     * head section
+     * @param {ScriptOptions[]} [options.scripts.body=[]] - Scripts for body section
+     * @param {StyleOptions[]} [options.styles=[]] - Stylesheet options
+     * @param {string[]} [options.headComponents=[]] - Array of SSR head component paths
+     * @param {string[]} [options.bodyComponents=[]] - Array of SSR body component paths
+     * @param {IconOptions} [options.icons={}] - Icon configuration
+     * @param {Object} [options.customPayload={}] - Custom data to inject into renderPayload
+     * @param {string} [options.configFile=''] - Path to JSON config file
+     * @param {string} [options.lang='en'] - HTML lang attribute
+     * @param {string} [options.dir='ltr'] - HTML dir attribute
+     * @param {Object} [options.microdata=[]] - Structured data (JSON-LD)
      * @returns {Promise<void>}
      * @memberof UnderpostStatic
-     *
-     * @example
-     * // Minimal usage
-     * await UnderpostStatic.API.callback({
-     *   page: './src/client/ssr/body/DefaultSplashScreen.js',
-     *   outputPath: './dist/index.html'
-     * });
-     *
-     * @example
-     * // Full customization with metadata and scripts
-     * await UnderpostStatic.API.callback({
-     *   page: './src/client/ssr/body/CustomPage.js',
-     *   outputPath: './dist/page.html',
-     *   metadata: {
-     *     title: 'My Custom Page',
-     *     description: 'A fully customized page',
-     *     keywords: ['custom', 'static', 'page'],
-     *     author: 'Jane Developer',
-     *     themeColor: '#4CAF50',
-     *     canonicalURL: 'https://example.com/page',
-     *     thumbnail: 'https://example.com/images/thumbnail.png',
-     *     locale: 'en-US',
-     *     siteName: 'My Website'
-     *   },
-     *   scripts: {
-     *     head: [
-     *       { src: 'https://cdn.example.com/analytics.js', async: true },
-     *       { content: 'window.config = { apiUrl: "https://api.example.com" };' }
-     *     ],
-     *     body: [
-     *       { src: '/app.js', type: 'module', defer: true }
-     *     ]
-     *   },
-     *   styles: [
-     *     { href: '/main.css' },
-     *     { content: 'body { font-family: sans-serif; }' }
-     *   ],
-     *   icons: {
-     *     favicon: '/favicon.ico',
-     *     appleTouchIcon: '/apple-touch-icon.png',
-     *     manifest: '/manifest.json'
-     *   },
-     *   headComponents: [
-     *     './src/client/ssr/head/Seo.js',
-     *     './src/client/ssr/head/Pwa.js'
-     *   ],
-     *   microdata: [
-     *     {
-     *       '@context': 'https://schema.org',
-     *       '@type': 'WebPage',
-     *       'name': 'My Custom Page',
-     *       'url': 'https://example.com/page'
-     *     }
-     *   ],
-     *   customPayload: {
-     *     apiEndpoint: 'https://api.example.com',
-     *     features: ['feature1', 'feature2']
-     *   },
-     *   env: 'production',
-     *   minify: true
-     * });
-     *
-     * @example
-     * // Using a config file
-     * await UnderpostStatic.API.callback({
-     *   configFile: './static-config.json',
-     *   outputPath: './dist/index.html'
-     * });
-     *
-     * @example
-     * // Generate with build trigger
-     * await UnderpostStatic.API.callback({
-     *   page: './src/client/ssr/body/DefaultSplashScreen.js',
-     *   outputPath: './public/index.html',
-     *   deployId: 'production-v1',
-     *   buildHost: 'example.com',
-     *   buildPath: '/',
-     *   build: true,
-     *   env: 'production'
-     * });
      */
-    async callback(options = {}) {
+    async callback(options = DefaultStaticGenerationOptions) {
+      // Handle config template generation
+      if (options.generateConfig) {
+        const configPath = typeof options.generateConfig === 'string' ? options.generateConfig : './static-config.json';
+        return UnderpostStatic.API.generateConfigTemplate(configPath);
+      }
+
+      // Parse comma-separated options
+      if (options.keywords) {
+        options.keywords = options.keywords.split(',').map((k) => k.trim());
+      }
+      if (options.headScripts) {
+        options.scripts = options.scripts || {};
+        options.scripts.head = options.headScripts.split(',').map((s) => ({ src: s.trim() }));
+      }
+      if (options.bodyScripts) {
+        options.scripts = options.scripts || {};
+        options.scripts.body = options.bodyScripts.split(',').map((s) => ({ src: s.trim() }));
+      }
+      if (options.styles) {
+        options.styles = options.styles.split(',').map((s) => ({ href: s.trim() }));
+      }
+      if (options.headComponents) {
+        options.headComponents = options.headComponents.split(',').map((c) => c.trim());
+      }
+      if (options.bodyComponents) {
+        options.bodyComponents = options.bodyComponents.split(',').map((c) => c.trim());
+      }
+
+      // Build metadata object from individual options
+      options.metadata = {
+        ...(options.title && { title: options.title }),
+        ...(options.description && { description: options.description }),
+        ...(options.keywords && { keywords: options.keywords }),
+        ...(options.author && { author: options.author }),
+        ...(options.themeColor && { themeColor: options.themeColor }),
+        ...(options.canonicalUrl && { canonicalURL: options.canonicalUrl }),
+        ...(options.thumbnail && { thumbnail: options.thumbnail }),
+        ...(options.locale && { locale: options.locale }),
+        ...(options.siteName && { siteName: options.siteName }),
+      };
+
+      // Build icons object
+      if (options.favicon || options.appleTouchIcon || options.manifest) {
+        options.icons = {
+          ...(options.favicon && { favicon: options.favicon }),
+          ...(options.appleTouchIcon && { appleTouchIcon: options.appleTouchIcon }),
+          ...(options.manifest && { manifest: options.manifest }),
+        };
+      }
+
       // Load config from file if specified
       if (options.configFile) {
         const fileConfig = ConfigLoader.load(options.configFile);
@@ -717,10 +626,6 @@ class UnderpostStatic {
      * @param {string} outputPath - Where to save the template config
      * @returns {void}
      * @memberof UnderpostStatic
-     *
-     * @example
-     * // Generate a template configuration file
-     * UnderpostStatic.API.generateConfigTemplate('./my-static-config.json');
      */
     generateConfigTemplate(outputPath = './static-config.json') {
       const template = {