scripts-orchestrator 2.0.0 → 2.3.0

package/README.md

@@ -39,13 +39,14 @@ Create a configuration file (default: `scripts-orchestrator.config.js`) that def
 
 ```javascript
 {
-  command: 'command_name',        // The npm script to run
-  description: 'Description',     // Optional description
-  status: 'enabled',             // 'enabled' or 'disabled'
-  attempts: 1,                   // Number of retry attempts
-  dependencies: [],              // Array of dependent commands
-  background: false,             // Whether to run in background
-  health_check: {                // Health check configuration
+  command: 'command_name',           // The npm script to run
+  description: 'Description',        // Optional description
+  status: 'enabled',                 // 'enabled' or 'disabled'
+  attempts: 1,                       // Number of retry attempts
+  dependencies: [],                 // Array of dependent commands
+  background: false,                // Whether to run in background
+  kill_command: 'kill_storybook',   // Optional kill command to kill the process
+  health_check: {                   // Health check configuration
     url: 'http://localhost:port',
     max_attempts: 20,
     interval: 2000
@@ -191,7 +192,6 @@ See [versions](./docs/versions.md)
 ## Roadmap
 - Better UX to indicate what is happening
 - Tests to avoid regression
-- Retry should append to the log file
 - Run any shell command rather than assume the command is specified in package.json (? tentative)
 
 

package/lib/health-check.js

@@ -1,4 +1,3 @@
-import { spawn } from 'child_process';
 import { log } from './logger.js';
 
 export class HealthCheck {
@@ -6,22 +5,46 @@ export class HealthCheck {
     this.logger = log;
   }
 
+  /**
+   * Static method to make a simple HTTP/HTTPS request
+   * @param {string} url - The URL to check
+   * @param {number} timeout - Request timeout in milliseconds (default: 5000)
+   * @returns {Promise<{statusCode: number|null, success: boolean, error?: string}>}
+   */
+  static async makeHttpRequest(url, timeout = 5000) {
+    try {
+      // Use Node.js http/https module instead of curl for cross-platform compatibility
+      const urlObj = new URL(url);
+      const isHttps = urlObj.protocol === 'https:';
+      const httpModule = isHttps ? await import('https') : await import('http');
+      
+      return await new Promise((resolve) => {
+        const req = httpModule.default.get(url, (res) => {
+          resolve({ statusCode: res.statusCode, success: true });
+          res.destroy(); // Close the response stream
+        });
+        
+        req.on('error', (error) => {
+          resolve({ statusCode: null, success: false, error: error.message });
+        });
+        
+        req.setTimeout(timeout, () => {
+          req.destroy();
+          resolve({ statusCode: null, success: false, error: 'Timeout' });
+        });
+      });
+    } catch (error) {
+      return { statusCode: null, success: false, error: error.message };
+    }
+  }
+
   async waitForUrl({url, maxAttempts = 20, interval = 2000, silent=false}) {
     !silent && this.logger.info(`Waiting for ${url} to be available...`);
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       try {
-        const result = await new Promise((resolve) => {
-          const curl = spawn('curl', ['-s', '-o', '/dev/null', '-w', '%{http_code}', url]);
-          let output = '';
-          curl.stdout.on('data', (data) => {
-            output += data.toString();
-          });
-          curl.on('close', (code) => {
-            resolve({ code, output });
-          });
-        });
+        const result = await HealthCheck.makeHttpRequest(url, 5000);
 
-        if (result.code === 0 && result.output === '200') {
+        if (result.success && result.statusCode === 200) {
           !silent && this.logger.success(`${url} is available`);
           return true;
         }

package/lib/orchestrator.js

@@ -52,6 +52,7 @@ export class Orchestrator {
       should_retry,
       process_tracking = false,
       health_check,
+      kill_command,
     } = commandConfig;
 
     const startTime = Date.now();
@@ -87,6 +88,7 @@ export class Orchestrator {
           url: checkUrl,
           startedByScript: false,
           process_tracking,
+          kill_command,
         });
         this.commandTimings.set(command, Date.now() - startTime);
         visited.delete(command);
@@ -144,12 +146,14 @@ export class Orchestrator {
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
 
-      const { success, output } = await this.processManager.runCommand(
-        attempt === 1 ? command : retry_command || command,
+      const { success, output } = await this.processManager.runCommand({
+        cmd: attempt === 1 ? command : retry_command || command,
         logFile,
         background,
-        health_check,
-      );
+        healthCheck: health_check,
+        kill_command,
+        isRetry: attempt > 1,
+      });
       commandOutput = output;
       result = success;
 
@@ -175,6 +179,16 @@ export class Orchestrator {
 
     if (commandFailed) {
       this.failedCommands.push(command);
+      
+      // Cleanup any background processes for this failed command
+      if (background) {
+        this.logger.warn(`Command ${command} failed after all attempts. Cleaning up background processes.`);
+        try {
+          await this.processManager.cleanupCommand(command);
+        } catch (cleanupError) {
+          this.logger.error(`Failed to cleanup processes for ${command}: ${cleanupError.message}`);
+        }
+      }
     }
 
     this.commandTimings.set(command, Date.now() - startTime);

package/lib/process-manager.js

@@ -2,6 +2,7 @@ import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { log } from './logger.js';
+import { HealthCheck } from './health-check.js';
 
 
 export class ProcessManager {
@@ -11,17 +12,18 @@ export class ProcessManager {
     this.backgroundProcessesDetails = [];
   }
 
-  addBackgroundProcess({ command, url, startedByScript, process_tracking }) {
+  addBackgroundProcess({ command, url, startedByScript, process_tracking, kill_command }) {
     this.logger.verbose(`Adding background process: ${command} (${url})`);
     this.backgroundProcessesDetails.push({
       command,
       url,
       startedByScript,
       process_tracking,
+      kill_command,
     });
   }
 
-  async runCommand(cmd, logFile, background = false, healthCheck = null) {
+  async runCommand({ cmd, logFile, background = false, healthCheck = null, kill_command = null, isRetry = false }) {
     const LOGS_DIR = path.resolve(process.cwd(), 'scripts-orchestrator-logs');
     const LOG_FILE = logFile || path.join(LOGS_DIR, `${cmd}.log`);
 
@@ -31,8 +33,12 @@ export class ProcessManager {
         fs.mkdirSync(LOGS_DIR, { recursive: true });
       }
 
-      this.logger.verbose(`Clearing log file at ${LOG_FILE}`);
-      fs.writeFileSync(LOG_FILE, ''); // Clear the log file
+      if (!isRetry) {
+        this.logger.verbose(`Clearing log file at ${LOG_FILE}`);
+        fs.writeFileSync(LOG_FILE, ''); // Clear the log file
+      } else {
+        this.logger.verbose(`Appending to existing log file at ${LOG_FILE} (retry attempt)`);
+      }
     } catch (error) {
       this.logger.error(`Failed to setup log file: ${error.message}`);
       return Promise.resolve({ success: false, output: '' });
@@ -42,7 +48,7 @@ export class ProcessManager {
       this.logger.info(`Running: npm run ${cmd}`);
       
       // Create isolated environment for each process
-      const isolatedEnv = this.createIsolatedEnvironment(cmd);
+      const isolatedEnv = this.createIsolatedEnvironment({ command: cmd });
       
       const options = {
         shell: true,
@@ -103,6 +109,7 @@ export class ProcessManager {
                   startTime: Date.now(),
                   url: healthCheck?.url,
                   startedByScript: true,
+                  kill_command,
                 });
                 
                 this.logger.verbose(`Unreferencing process ${processGroupId}`);
@@ -172,7 +179,7 @@ export class ProcessManager {
     });
   }
 
-  createIsolatedEnvironment(command) {
+  createIsolatedEnvironment({ command }) {
     // Create a deep copy to avoid any reference sharing
     const baseEnv = JSON.parse(JSON.stringify(process.env));
     
@@ -201,121 +208,246 @@ export class ProcessManager {
 
   async cleanup() {
     this.logger.info('\nCleaning up background processes...');
+    
+    // Debug: Log the number of processes we're tracking
+    this.logger.info(`- Found ${this.backgroundProcessesDetails.length} background processes to clean up`);
+    
+    // Debug: Log each process details
+    this.backgroundProcessesDetails.forEach(({ command, pgid, url, startedByScript, kill_command }, index) => {
+      this.logger.verbose(`- Process ${index + 1}: command=${command}, pgid=${pgid}, url=${url}, startedByScript=${startedByScript}, kill_command=${kill_command}`);
+    });
+    
     const killPromises = this.backgroundProcessesDetails.map(
-      async ({ command, pgid, url, startedByScript }) => {
-        if (!startedByScript) {
-          this.logger.verbose(
-            `- Skipping cleanup for ${command} (${url}) as it was not started by this script`,
-          );
+      async ({ command, pgid, url, startedByScript, kill_command }) => {
+        await this.cleanupProcess({ command, pgid, url, startedByScript, kill_command });
+      },
+    );
+
+    await Promise.all(killPromises);
+    this.backgroundProcesses = [];
+    this.backgroundProcessesDetails = [];
+  }
+
+  async cleanupCommand(commandName) {
+    this.logger.info(`\nCleaning up processes for command: ${commandName}`);
+    
+    // Find processes for this specific command
+    const commandProcesses = this.backgroundProcessesDetails.filter(
+      ({ command }) => command === commandName
+    );
+    
+    if (commandProcesses.length === 0) {
+      this.logger.verbose(`- No background processes found for command: ${commandName}`);
+      return;
+    }
+    
+    this.logger.verbose(`- Found ${commandProcesses.length} background processes for command: ${commandName}`);
+    
+    const killPromises = commandProcesses.map(
+      async ({ command, pgid, url, startedByScript, kill_command }) => {
+        await this.cleanupProcess({ command, pgid, url, startedByScript, kill_command });
+      }
+    );
+
+    await Promise.all(killPromises);
+    
+    // Remove the cleaned up processes from our tracking arrays
+    this.backgroundProcesses = this.backgroundProcesses.filter(pgid => 
+      !commandProcesses.some(proc => proc.pgid === pgid)
+    );
+    this.backgroundProcessesDetails = this.backgroundProcessesDetails.filter(
+      ({ command }) => command !== commandName
+    );
+  }
+
+  async cleanupProcess({ command, pgid, url, startedByScript, kill_command }) {
+    if (!startedByScript) {
+      this.logger.verbose(
+        `- Skipping cleanup for ${command} (${url}) as it was not started by this script`,
+      );
+      return;
+    }
+
+    this.logger.verbose(`- Processing cleanup for ${command} (kill_command: ${kill_command})`);
+
+    // Try custom kill command first if specified
+    if (kill_command) {
+      try {
+        this.logger.verbose(`- Using custom kill command: npm run ${kill_command}`);
+        const result = await this.runCommand({ cmd: kill_command, logFile: null, background: false });
+        if (result.success) {
+          this.logger.verbose(`- Successfully killed ${command} using custom command`);
           return;
+        } else {
+          this.logger.verbose('- Custom kill command failed, falling back to process signals');
         }
+      } catch (error) {
+        this.logger.verbose(`- Custom kill command error: ${error.message}, falling back`);
+      }
+    } else {
+      this.logger.verbose(`- No kill_command specified for ${command}, using process signals`);
+    }
+
+    try {
+      // First try to kill the process group
+      try {
+        process.kill(pgid, 0);
+      } catch (error) {
+        this.logger.verbose(
+          `- Process ${command} (PGID: ${pgid}) already terminated`,
+        );
+        return;
+      }
 
+      // Cross-platform process termination
+      const isWindows = process.platform === 'win32';
+      
+      if (isWindows) {
+        // Windows: use taskkill to terminate process tree
         try {
-          // First try to kill the process group
+          const killProcess = spawn('taskkill', ['/F', '/T', '/PID', pgid.toString()]);
+          await new Promise((resolve) => {
+            killProcess.on('close', resolve);
+          });
+          this.logger.verbose(`- Terminated background process: ${command} (PID: ${pgid})`);
+          return;
+        } catch (killError) {
+          this.logger.verbose(`- Failed to use taskkill, falling back to process.kill: ${killError.message}`);
+        }
+      }
+      
+      // Unix/Linux/macOS or Windows fallback: Try SIGTERM first
+      process.kill(pgid, 'SIGTERM');
+
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          clearInterval(checkInterval);
+          reject(new Error('Process termination timeout'));
+        }, 5000);
+
+        const checkInterval = setInterval(() => {
           try {
             process.kill(pgid, 0);
           } catch (error) {
-            this.logger.verbose(
-              `- Process ${command} (PGID: ${pgid}) already terminated`,
-            );
-            return;
+            clearInterval(checkInterval);
+            clearTimeout(timeout);
+            resolve();
           }
+        }, 100);
+      });
+      this.logger.verbose(
+        `- Terminated background process: ${command} (PGID: ${pgid})`,
+      );
+    } catch (error) {
+      this.logger.verbose(`- Failed to terminate process group: ${error.message}`);
+    }
 
-          // Try SIGTERM first
-          process.kill(pgid, 'SIGTERM');
-
-          await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-              clearInterval(checkInterval);
-              reject(new Error('Process termination timeout'));
-            }, 5000);
-
-            const checkInterval = setInterval(() => {
-              try {
-                process.kill(pgid, 0);
-              } catch (error) {
-                clearInterval(checkInterval);
-                clearTimeout(timeout);
-                resolve();
-              }
-            }, 100);
-          });
-          this.logger.verbose(
-            `- Terminated background process: ${command} (PGID: ${pgid})`,
-          );
-        } catch (error) {
-          this.logger.verbose(`- Failed to terminate process group: ${error.message}`);
-        }
-
-        // Check if the URL is still responding after termination attempt
-        if (url) {
+    // Check if the URL is still responding after termination attempt
+    if (url) {
+      try {
+        const urlObj = new URL(url);
+        const port = urlObj.port || (urlObj.protocol === 'https:' ? '443' : '80');
+        
+        // Use shared HTTP utility for cross-platform compatibility
+        const urlResult = await HealthCheck.makeHttpRequest(url, 2000);
+        
+        if (urlResult.success && urlResult.statusCode === 200) {
+          this.logger.verbose(`- URL ${url} is still responding after termination, finding process on port ${port}`);
+          
+          // Find and kill process using the port - cross-platform approach
           try {
-            const urlObj = new URL(url);
-            const port = urlObj.port || (urlObj.protocol === 'https:' ? '443' : '80');
+            const isWindows = process.platform === 'win32';
+            let findPortCmd, findPortArgs;
+            
+            if (isWindows) {
+              // Windows: use netstat
+              findPortCmd = 'netstat';
+              findPortArgs = ['-ano'];
+            } else {
+              // Unix/Linux/macOS: use lsof
+              findPortCmd = 'lsof';
+              findPortArgs = ['-i', `:${port}`, '-t'];
+            }
             
-            const curl = spawn('curl', ['-s', '-o', '/dev/null', '-w', '%{http_code}', url]);
+            const findProcess = spawn(findPortCmd, findPortArgs);
             const result = await new Promise((resolve) => {
               let output = '';
-              curl.stdout.on('data', (data) => {
+              findProcess.stdout.on('data', (data) => {
                 output += data.toString();
               });
-              curl.on('close', (code) => {
+              findProcess.on('close', (code) => {
                 resolve({ code, output });
               });
             });
 
-            if (result.code === 0 && result.output === '200') {
-              this.logger.verbose(`- URL ${url} is still responding after termination, finding process on port ${port}`);
+            if (result.code === 0 && result.output.trim()) {
+              let pids = [];
               
-              // Find and kill process using the port
-              try {
-                const lsof = spawn('lsof', ['-i', `:${port}`, '-t']);
-                const result = await new Promise((resolve) => {
-                  let output = '';
-                  lsof.stdout.on('data', (data) => {
-                    output += data.toString();
-                  });
-                  lsof.on('close', (code) => {
-                    resolve({ code, output });
-                  });
-                });
-
-                if (result.code === 0 && result.output.trim()) {
-                  const pids = result.output.trim().split('\n');
-                  for (const pid of pids) {
-                    try {
-                      process.kill(parseInt(pid), 'SIGKILL');
-                      this.logger.verbose(`- Killed process (PID: ${pid}) using port ${port}`);
-                    } catch (killError) {
-                      if (killError.code !== 'ESRCH') {
-                        this.logger.error(`- Failed to kill process (PID: ${pid}): ${killError.message}`);
-                      }
+              if (isWindows) {
+                // Parse netstat output to find PIDs for the specific port
+                const lines = result.output.split('\n');
+                for (const line of lines) {
+                  if (line.includes(`:${port} `) && line.includes('LISTENING')) {
+                    const parts = line.trim().split(/\s+/);
+                    const pid = parts[parts.length - 1];
+                    if (pid && !isNaN(pid)) {
+                      pids.push(pid);
                     }
                   }
                 }
-              } catch (lsofError) {
-                this.logger.error(`- Failed to find process using port ${port}: ${lsofError.message}`);
+              } else {
+                // lsof output is already just PIDs
+                pids = result.output.trim().split('\n');
+              }
+              
+              for (const pid of pids) {
+                try {
+                  if (isWindows) {
+                    // Windows: use taskkill
+                    const killProcess = spawn('taskkill', ['/F', '/PID', pid]);
+                    await new Promise((resolve) => {
+                      killProcess.on('close', resolve);
+                    });
+                  } else {
+                    // Unix/Linux/macOS: use process.kill
+                    process.kill(parseInt(pid), 'SIGKILL');
+                  }
+                  this.logger.verbose(`- Killed process (PID: ${pid}) using port ${port}`);
+                } catch (killError) {
+                  if (killError.code !== 'ESRCH') {
+                    this.logger.error(`- Failed to kill process (PID: ${pid}): ${killError.message}`);
+                  }
+                }
               }
             }
-          } catch (error) {
-            this.logger.verbose(`- URL check failed: ${error.message}`);
+          } catch (portError) {
+            this.logger.error(`- Failed to find process using port ${port}: ${portError.message}`);
           }
         }
+      } catch (error) {
+        this.logger.verbose(`- URL check failed: ${error.message}`);
+      }
+    }
 
-        // Final attempt to kill the process group with SIGKILL
-        try {
-          process.kill(pgid, 'SIGKILL');
-        } catch (error) {
-          if (error.code !== 'ESRCH') {
-            this.logger.error(`- Failed to kill process group with SIGKILL: ${error.message}`);
-          }
-        }
-      },
-    );
-
-    await Promise.all(killPromises);
-    this.backgroundProcesses = [];
-    this.backgroundProcessesDetails = [];
+    // Final attempt to kill the process group
+    try {
+      const isWindows = process.platform === 'win32';
+      
+      if (isWindows) {
+        // Windows: force kill with taskkill
+        const killProcess = spawn('taskkill', ['/F', '/T', '/PID', pgid.toString()]);
+        await new Promise((resolve) => {
+          killProcess.on('close', resolve);
+        });
+      } else {
+        // Unix/Linux/macOS: use SIGKILL
+        process.kill(pgid, 'SIGKILL');
+      }
+    } catch (error) {
+      if (error.code !== 'ESRCH') {
+        this.logger.error(`- Failed to kill process group: ${error.message}`);
+      }
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripts-orchestrator",
-  "version": "2.0.0",
+  "version": "2.3.0",
   "description": "A powerful script orchestrator for running parallel commands with dependency management, background processes, and health checks",
   "main": "lib/index.js",
   "type": "module",

package/scripts-orchestrator.config.js

@@ -1,83 +1,115 @@
-export default [
-  {
-    command: 'build',
-    description: 'Build the project',
-    status: 'enabled',
-    attempts: 1,
-  },
-  {
-    command: 'test-ci',
-    description: 'Run unit tests',
-    status: 'enabled',
-    attempts: 2,
-    should_retry: (output) => {
-      // Check for actual test failures in the summary
-      const testSummaryMatch = output.match(/Test Suites:.*?(\d+) failed/);
-      const hasTestFailures =
-        testSummaryMatch && parseInt(testSummaryMatch[1]) > 0;
+export default {
+  phases: [
+    {
+      name: 'build',
+      parallel: [
+        {
+          command: 'build',
+          description: 'Build the project',
+          status: 'enabled',
+          attempts: 1,
+        },
+        {
+          command: 'stylelint',
+          description: 'Run stylelint checks',
+          status: 'enabled',
+        },
+        { command: 'lint', description: 'Run lint checks', status: 'enabled' },
+        {
+          command: 'jscpd',
+          description: 'Run code duplication checks',
+          status: 'enabled',
+        },
+      ],
+    },
+    {
+      name: 'storybook tests',
+      parallel: [
+        {
+          command: 'test-storybook',
+          description: 'Run Storybook tests',
+          status: 'enabled',
+          attempts: 2,
+          dependencies: [
+            {
+              command: 'storybook_silent',
+              background: true,
+              wait: 5000,
+              kill_command: 'kill_storybook',
+              dependencies: [],
+              // Add process tracking
+              process_tracking: true,
+              // Add health check
+              health_check: {
+                url: 'http://localhost:6006',
+                max_attempts: 20,
+                interval: 2000,
+              },
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'unit tests',
+      parallel: [
+        {
+          command: 'test-ci',
+          description: 'Run unit tests',
+          status: 'enabled',
+          attempts: 2,
+          should_retry: (output) => {
+            // Check for test failures in both formats
+            const testSuiteFailureMatch = output.match(
+              /Test Suites:.*?\(\d+\) failed/,
+            );
+            const individualTestFailureMatch =
+              output.match(/✘\s*(\d+)\s*failing/);
+
+            const hasTestSuiteFailures =
+              testSuiteFailureMatch && parseInt(testSuiteFailureMatch[1]) > 0;
+            const hasIndividualTestFailures =
+              individualTestFailureMatch &&
+              parseInt(individualTestFailureMatch[1]) > 0;
+
+            const hasTestFailures =
+              hasTestSuiteFailures || hasIndividualTestFailures;
 
-      // Check for coverage failures
-      const coverageSummaryMatch = output.match(
-        /Jest: "global" coverage threshold/,
-      );
-      const hasCoverageFailures = coverageSummaryMatch !== null;
+            // Check for "Test suite failed to run" in logs
+            if (output.includes('Test suite failed to run')) {
+              console.error('Certain tests could not be run');
+              return false; // Don't retry if certain tests could not be run
+            }
 
-      if (!hasTestFailures && hasCoverageFailures) {
-        console.log(
-          'Tests have passed but coverage thresholds have not been met',
-        );
-        return false; // Don't retry if only coverage failed
-      }
+            if (!hasTestFailures) {
+              console.log(
+                'Tests have passed but coverage thresholds have not been met',
+              );
+              return false; // Don't retry if only coverage failed
+            }
 
-      return hasTestFailures; // Only retry if there are actual test failures
+            return hasTestFailures; // Only retry if there are actual test failures
+          },
+        },
+      ],
     },
-  },
-  {
-    command: 'test-storybook',
-    description: 'Run Storybook tests',
-    status: 'enabled',
-    attempts: 2,
-    dependencies: [
-      {
-        command: 'storybook_silent',
-        background: true,
-        wait: 5000,
-        kill_script: 'kill_storybook',
-        dependencies: [],
-        // Add process tracking
-        process_tracking: true,
-        // Add health check
-        health_check: {
-          url: 'http://localhost:6006',
-          max_attempts: 20,
-          interval: 2000,
+    {
+      name: 'playwright',
+      parallel: [
+        {
+          command: 'playwright_ci',
+          description: 'Run Playwright tests',
+          status: 'enabled',
+          attempts: 1, //Playwright internally retries in CI mode
+          dependencies: [
+            {
+              command: 'dev',
+              background: true,
+              url: 'http://localhost:5173',
+            },
+          ],
         },
-      },
-    ],
-  },
-  {
-    command: 'stylelint',
-    description: 'Run stylelint checks',
-    status: 'enabled',
-  },
-  { command: 'lint', description: 'Run lint checks', status: 'enabled' },
-  {
-    command: 'jscpd',
-    description: 'Run code duplication checks',
-    status: 'enabled',
-  },
-  {
-    command: 'playwright_ci',
-    description: 'Run Playwright tests',
-    status: 'enabled',
-    attempts: 1, //Playwright internally retries in CI mode
-    dependencies: [
-      {
-        command: 'dev',
-        background: true,
-        url: 'http://localhost:5173',
-        kill: 'application_end',
-      },
-    ],
-  },
-];
+      ],
+    },
+  ],
+};