@magnolia/cli-jumpstart-plugin 1.0.0-preview.1

package/README.md

@@ -0,0 +1,63 @@
+# CLI Jumpstart Plugin
+
+**NOTE:** *This version of the Jumpstart plugin is still under development. The README will be updated continuosly as we refine the plugin.*
+
+The Jumpstart Plugin is a part of the Magnolia CLI's plugin system. This plugin is designed to facilitate the process of starting new projects using predefined templates and bundles. It allows users to choose a template and download associated bundles while performing necessary tasks such as authentication, bundle downloading, extraction, and post-command execution.
+
+## Installation
+
+The Jumpstart plugin is by default installed in the MGNL plugin-system and ready to be used.
+
+## Usage
+The Jumpstart Plugin enhances the Magnolia CLI by providing a streamlined way to start new projects using predefined templates and bundles. Users can select templates, which are collections of bundles, and have the plugin handle the download, extraction, and execution of post-commands.
+
+**Jumpstart command:**
+
+```bash
+magnolia-cli jumpstart
+```
+
+This command initiates the **jumpstart** plugin.
+When run, the plugin will prompt the user to select a template. It will then proceed to download and extract the required bundles, executing post-commands if specified, install required plugins, initialize package.json project and create mgnl.config.js.
+
+
+![select-template.png](images/select-template.png)
+
+
+### **command-line options**
+
+You can customize the **jumpstart** plugin's actions using these command-line options:
+- `-t, --template <name>`:  Choose template.
+- `-p, --projectTemplatesPath <path>`: Specify from where the projectTemplates should be loaded.
+
+**Template option:**
+With this option, you can specify which template to use:
+
+```bash
+magnolia-cli jumpstart --template "headless/minimal-headless-spa-demos/dx-core/latest"
+```
+
+
+**Project templates list:**
+
+The **jumpstart** plugin relies on a list of predefined project templates stored in an external [repository](https://git.magnolia-cms.com/projects/SERVICES/repos/cli-project-templates/raw/projectTemplates.json). 
+You can specify your own project templates list with the *--project-templates-path* command:
+
+```bash
+magnolia-cli jumpstart -p "<project-templates-path>"
+```
+
+**Light-modules folder:**
+
+The Jumpstart Plugin initiates a recursive search throughout the project's directory structure for an existing `light-modules` directory. Upon detection, the plugin avoids creating a new one, instead utilizing the existing directory to maintain the pre-configured modules. On the other hand, if a `light-modules` directory is not found, the system will generate one.
+
+**magnolia.properties file:**
+
+The Jumpstart Plugin automatically applies specific modifications to the 'magnolia.properties' files of magnoliaAuthor and magnoliaPublic webapps.
+
+Following properties are modified:
+- 'magnolia.resources.dir' is adjusted to reference the `light-modules` directory.
+- 'magnolia.update.auto' is set to true
+
+## Conclusion
+The Jumpstart Plugin demonstrates an effective way to streamline the process of setting up new projects by providing template-based automation for downloading, extracting, and handling bundles. With its intuitive command-line interface and detailed documentation, users can quickly get started with the Magnolia CLI's powerful plugin system.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default } from './jumpstart-plugin.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { default } from './jumpstart-plugin.js';

package/dist/jumpstart-plugin.d.ts

@@ -0,0 +1,23 @@
+import { PluginTemplate } from '@magnolia/cli-plugin-template';
+import { Option } from 'commander';
+import { PluginOptions, Template, Bundle, TemplateWithoutChildren } from "./types/types.js";
+import { Logger } from "winston";
+export declare let logger: Logger;
+export default class JumpstartPlugin extends PluginTemplate {
+    name: string;
+    version: any;
+    description: any;
+    projectTemplates?: Array<Template>;
+    options: Option[];
+    constructor();
+    executePostCommands(bundle: Bundle, file: string): Promise<void>;
+    handleTemplate(template: TemplateWithoutChildren): Promise<void>;
+    setProjectTemplates(options: PluginOptions): Promise<void>;
+    promptTemplateSelection(templates: Array<Template>): Promise<TemplateWithoutChildren | undefined>;
+    findTemplateByIdentifier(identifier: string): TemplateWithoutChildren | undefined;
+    chooseTemplate(options: PluginOptions): Promise<void>;
+    init(winstonLogger: Logger): Promise<void>;
+    start(options: PluginOptions): Promise<void>;
+    stop(): Promise<void>;
+    help(): Promise<void>;
+}

package/dist/jumpstart-plugin.js

@@ -0,0 +1,217 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PluginTemplate } from '@magnolia/cli-plugin-template';
+import { Option } from 'commander';
+import { createRequire } from 'module';
+const requireFn = createRequire(import.meta.url);
+const pkg = requireFn('./package.json');
+import inquirer from 'inquirer';
+import axios from "axios";
+import { extract } from "./lib/extract.js";
+import { downloadBundle } from "./lib/download.js";
+import { PostCommands } from "./types/types.js";
+import { installDependencies } from "./lib/install.js";
+import path from "path";
+import { handleLightModulesFolder, initializeNodeProject, installAdditionalPlugins } from "./lib/helper.js";
+export let logger;
+export default class JumpstartPlugin extends PluginTemplate {
+    constructor() {
+        super();
+        this.name = "jumpstart";
+        this.version = pkg.version;
+        this.description = pkg.description;
+        this.options = [
+            new Option('-t, --template <name>', 'Choose template'),
+            new Option('-p, --project-templates-path <path>', 'Specify from where the projectTemplates should be loaded')
+        ];
+    }
+    executePostCommands(bundle, file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!bundle.postCommand)
+                return;
+            for (const command of bundle.postCommand) {
+                switch (command) {
+                    case PostCommands.Extract:
+                    case PostCommands.ExtractAndOverride:
+                        yield extract(bundle, file, command);
+                        break;
+                    case PostCommands.NpmInstall:
+                    case PostCommands.YarnInstall:
+                        yield installDependencies(bundle, command);
+                        break;
+                }
+            }
+        });
+    }
+    handleTemplate(template) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let templateCredentials;
+            if (template.auth) {
+                console.log("Please enter credentials for ", template.name);
+                templateCredentials = yield inquirer
+                    .prompt([
+                    {
+                        type: 'input',
+                        name: 'username',
+                        message: 'Username'
+                    },
+                    {
+                        type: 'password',
+                        name: 'password',
+                        message: 'Password'
+                    }
+                ]);
+            }
+            for (const bundle of template.bundles || []) {
+                let credentials = null;
+                let file;
+                try {
+                    if (bundle.auth === "inherit") {
+                        file = yield downloadBundle(bundle, templateCredentials, undefined);
+                    }
+                    else if (bundle.auth) {
+                        console.log("Please enter credentials for ", bundle.name ? bundle.name : bundle.url);
+                        credentials = yield inquirer
+                            .prompt([
+                            {
+                                type: 'input',
+                                name: 'username',
+                                message: 'Username'
+                            },
+                            {
+                                type: 'password',
+                                name: 'password',
+                                message: 'Password'
+                            }
+                        ]);
+                        file = yield downloadBundle(bundle, credentials, undefined);
+                    }
+                    else {
+                        file = yield downloadBundle(bundle, null, undefined);
+                    }
+                    if (file) {
+                        yield this.executePostCommands(bundle, file);
+                    }
+                }
+                catch (e) {
+                    logger.error(e.message);
+                }
+            }
+            yield handleLightModulesFolder();
+            yield initializeNodeProject();
+            if (template.plugins) {
+                yield installAdditionalPlugins(template.plugins);
+            }
+        });
+    }
+    setProjectTemplates(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if ((_a = options.projectTemplatesPath) === null || _a === void 0 ? void 0 : _a.startsWith("http", 0)) {
+                    const res = yield axios.get(options.projectTemplatesPath);
+                    this.projectTemplates = res.data.projectTemplates;
+                }
+                else if (options.projectTemplatesPath) {
+                    this.projectTemplates = requireFn(path.join(process.cwd(), options.projectTemplatesPath)).projectTemplates;
+                }
+                else {
+                    const res = yield axios.get("https://git.magnolia-cms.com/rest/api/latest/projects/SERVICES/repos/cli-project-templates/raw/projectTemplates.json");
+                    this.projectTemplates = res.data.projectTemplates;
+                }
+            }
+            catch (e) {
+                logger.error(e.message);
+            }
+        });
+    }
+    promptTemplateSelection(templates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!templates || !templates.length) {
+                return;
+            }
+            const choices = templates.map(template => {
+                return {
+                    name: template.name,
+                    value: template
+                };
+            });
+            const { template } = yield inquirer.prompt([
+                {
+                    type: 'rawlist',
+                    name: 'template',
+                    message: 'Please choose a template?',
+                    choices: choices
+                }
+            ]);
+            if (template.children && template.children.length) {
+                return this.promptTemplateSelection(template.children);
+            }
+            if (template.bundles || template.plugins) {
+                return template;
+            }
+        });
+    }
+    findTemplateByIdentifier(identifier) {
+        if (!this.projectTemplates)
+            return;
+        let currentTemplates = this.projectTemplates;
+        for (const segment of identifier.split('/')) {
+            const foundTemplate = currentTemplates.find((template) => template.name === segment);
+            if (!foundTemplate)
+                return;
+            if (foundTemplate.bundles || foundTemplate.plugins)
+                return foundTemplate;
+            currentTemplates = foundTemplate.children;
+        }
+    }
+    chooseTemplate(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.projectTemplates)
+                return;
+            if (typeof options.template === 'string') {
+                const template = this.findTemplateByIdentifier(options.template);
+                if (template) {
+                    yield this.handleTemplate(template);
+                    return;
+                }
+                else {
+                    logger.info(`The '${options.template}' template was not found.`);
+                }
+            }
+            const template = yield this.promptTemplateSelection(this.projectTemplates);
+            if (template) {
+                yield this.handleTemplate(template);
+            }
+        });
+    }
+    init(winstonLogger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger = winstonLogger;
+        });
+    }
+    start(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger === null || logger === void 0 ? void 0 : logger.info(`'JumpstartPlugin' plugin started succesfully.`);
+            yield this.setProjectTemplates(options);
+            yield this.chooseTemplate(options);
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Plugin stopped");
+        });
+    }
+    help() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Plugin help");
+        });
+    }
+}

package/dist/lib/config-helper.d.ts

@@ -0,0 +1,3 @@
+import { PluginRequirement } from "../types/types.js";
+export declare const handleMGNLConfigFile: () => Promise<void>;
+export declare const installAndConfigPlugins: (plugins: Array<PluginRequirement>) => Promise<void>;

package/dist/lib/config-helper.js

@@ -0,0 +1,221 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from "fs-extra";
+import parser from "@babel/parser";
+import t from "@babel/types";
+import beautifyModule from "js-beautify";
+import path from "path";
+import { determinePackageManager, extractRepoName, installPackage, isValidURL } from "./helper.js";
+import ora from "ora";
+import { logger } from "../jumpstart-plugin.js";
+const { js_beautify } = beautifyModule;
+const BEAUTIFY_OPTIONS = {
+    indent_size: 2,
+    end_with_newline: true,
+    max_preserve_newlines: 2,
+    keep_array_indentation: false,
+    preserve_newlines: true
+};
+const getLocalConfigPath = () => path.join(process.cwd(), 'mgnl.config.js');
+const getPackageConfigPath = () => path.join(process.cwd(), 'node_modules/@magnolia/cli/mgnl.config.js');
+export const handleMGNLConfigFile = () => __awaiter(void 0, void 0, void 0, function* () {
+    let isMgnlCliInstalled = true;
+    if (!fs.existsSync(getPackageConfigPath())) {
+        isMgnlCliInstalled = yield installPackage(determinePackageManager(), "@magnolia/cli@preview");
+        logger === null || logger === void 0 ? void 0 : logger.warn("Couldn't install @magnolia/cli");
+    }
+    if (isMgnlCliInstalled && fs.existsSync(getLocalConfigPath())) {
+        handleExistingConfigFile();
+    }
+    else if (isMgnlCliInstalled && !fs.existsSync(getLocalConfigPath())) {
+        createMgnlConfigFile();
+    }
+    else if (!isMgnlCliInstalled && !fs.existsSync(getLocalConfigPath())) {
+        createSimpleMgnlConfigFile();
+    }
+    else {
+        // the mgnl.config.js exist, do not do anything
+    }
+});
+export const installAndConfigPlugins = (plugins) => __awaiter(void 0, void 0, void 0, function* () {
+    const localConfig = parseConfigFile(getLocalConfigPath());
+    if (!localConfig)
+        return;
+    const missingPlugins = findMissingPlugins(plugins, localConfig);
+    if (missingPlugins.length === 0)
+        return;
+    logger === null || logger === void 0 ? void 0 : logger.info(`Will attempt to install missing plugins`);
+    const installedPlugins = yield installPlugins(missingPlugins);
+    const pluginsConfig = createCustomConfigForPlugins(installedPlugins);
+    updateLocalConfig(pluginsConfig, localConfig);
+});
+const handleExistingConfigFile = () => {
+    const localConfigContent = fs.readFileSync(getLocalConfigPath(), "utf8");
+    const packageConfigContent = fs.readFileSync(getPackageConfigPath(), "utf8");
+    const localLoggerConfig = extractLoggerConfig(localConfigContent);
+    const globalLoggerConfig = extractLoggerConfig(packageConfigContent);
+    if (!localLoggerConfig && (globalLoggerConfig && globalLoggerConfig[1])) {
+        const loggerContent = getLoggerContent(globalLoggerConfig[1]);
+        const newLocalConfigContent = localConfigContent.replace(/(export default \{)/, `$1${loggerContent}`);
+        writeConfigContent(newLocalConfigContent);
+    }
+};
+function createMgnlConfigFile() {
+    const packageConfigContent = fs.readFileSync(getPackageConfigPath(), "utf8");
+    const loggerConfig = extractLoggerConfig(packageConfigContent);
+    const mgnlConfigPrefix = `
+    export default {`;
+    const logger = loggerConfig && loggerConfig[1]
+        ? getLoggerContent(loggerConfig[1])
+        : '';
+    const mgnlConfigSufix = `
+    // Here you can add plugins you want to use with MGNL CLI
+    commands: []
+    };`;
+    const mgnlConfigContent = mgnlConfigPrefix + logger + mgnlConfigSufix;
+    writeConfigContent(mgnlConfigContent);
+}
+function createSimpleMgnlConfigFile() {
+    const mgnlConfigContent = `
+    export default {
+    // Here you can add plugins you want to use with MGNL CLI
+    commands: []
+    };`;
+    writeConfigContent(mgnlConfigContent);
+}
+function getLoggerContent(logger) {
+    return `
+    // Logger configuration
+    // see: https://github.com/winstonjs/winston#logging for logging levels explanation
+    ${logger},`;
+}
+const extractLoggerConfig = (content) => {
+    const loggerRegex = /(logger\s*:\s*{[^}]*})/s;
+    return loggerRegex.exec(content);
+};
+const findMissingPlugins = (plugins, config) => {
+    return plugins.filter(plugin => {
+        let packageName = plugin.name;
+        return !config.imports.some(customImport => customImport.importedNames === packageName);
+    });
+};
+const installPlugins = (plugins) => __awaiter(void 0, void 0, void 0, function* () {
+    const packageManager = determinePackageManager();
+    let installedPlugins = [];
+    for (const plugin of plugins) {
+        const installed = yield installPackage(packageManager, plugin.installReference, plugin.name);
+        if (installed)
+            installedPlugins.push(plugin);
+    }
+    return installedPlugins;
+});
+const createCustomConfigForPlugins = (plugins) => {
+    const defaultConfig = { configContent: "", imports: [], commands: [] };
+    plugins.forEach(plugin => {
+        let importSource;
+        if (isValidURL(plugin.installReference)) {
+            importSource = extractRepoName(plugin.installReference);
+        }
+        if (!importSource) {
+            importSource = plugin.installReference;
+        }
+        defaultConfig.imports.push({ importedNames: plugin.name, importSource: importSource });
+        defaultConfig.commands.push({ commandName: plugin.name });
+    });
+    return defaultConfig;
+};
+const parseConfigFile = (configPath) => {
+    let configContent;
+    try {
+        configContent = fs.readFileSync(configPath, 'utf-8');
+    }
+    catch (e) {
+        logger === null || logger === void 0 ? void 0 : logger.error(`Couldn't read ${configPath}`);
+        console.error(e);
+        return null;
+    }
+    let parsedConfig;
+    try {
+        parsedConfig = parser.parse(configContent, { sourceType: 'module' });
+    }
+    catch (e) {
+        logger === null || logger === void 0 ? void 0 : logger.error(`Couldn't parse ${configPath}, please check the file for issues`);
+        console.error(e);
+        return null;
+    }
+    if (!parsedConfig)
+        return null;
+    const { imports, commands } = extractImportsAndCommands(parsedConfig);
+    return { configContent, imports, commands };
+};
+const extractImportsAndCommands = (ast) => {
+    const imports = [];
+    const commands = [];
+    ast.program.body.forEach(node => {
+        if (t.isImportDeclaration(node)) {
+            imports.push({
+                importedNames: node.specifiers.map(specifier => specifier.local.name).join(', '),
+                importSource: node.source.value
+            });
+        }
+        if (t.isExportDefaultDeclaration(node) && t.isObjectExpression(node.declaration)) {
+            node.declaration.properties.forEach(property => {
+                if (t.isObjectProperty(property) && t.isArrayExpression(property.value)) {
+                    property.value.elements.forEach(element => {
+                        if (t.isNewExpression(element) && t.isIdentifier(element.callee)) {
+                            commands.push({ commandName: element.callee.name });
+                        }
+                    });
+                }
+            });
+        }
+    });
+    return { imports, commands };
+};
+const updateLocalConfig = (defaultConfig, localConfig) => {
+    const getMissingItems = (defaultItems, customItems, comparator) => {
+        return defaultItems.filter(defaultItem => !customItems.some(customItem => comparator(defaultItem, customItem)));
+    };
+    const mergeImports = (customImports, missingImports) => {
+        return customImports.concat(missingImports)
+            .map(i => `import ${i.importedNames} from "${i.importSource}";`).join('\n');
+    };
+    const missingImports = getMissingItems(defaultConfig.imports, localConfig.imports, (a, b) => a.importSource === b.importSource);
+    const missingCommands = getMissingItems(defaultConfig.commands, localConfig.commands, (a, b) => a.commandName === b.commandName);
+    const mergedImports = mergeImports(localConfig.imports, missingImports);
+    const updatedConfigContent = mergeCommandsWithConfigContent(localConfig.configContent, missingCommands);
+    writeToLocalConfigFile(mergedImports, updatedConfigContent);
+};
+const mergeCommandsWithConfigContent = (configContent, missingCommands) => {
+    const missingCommandsStr = missingCommands.map(c => `new ${c.commandName}()`).join(',\n');
+    const commandsPattern = /(commands\s*:\s*\[)([^\]]*?)(,\s*)?(\])/;
+    return configContent.replace(commandsPattern, (match, p1, p2, p3, p4) => {
+        const separator = (p2.trim() !== "" && missingCommandsStr.trim() !== "") ? "," : "";
+        return `${p1}${p2}${separator}${missingCommandsStr}${p4}`;
+    });
+};
+const writeToLocalConfigFile = (mergedImports, updatedConfigContent) => {
+    const importPattern = /import .* from ['"].*['"];\s*/g;
+    const configContentWithImports = `${mergedImports}\n\n${updatedConfigContent.replace(importPattern, '')}`;
+    writeConfigContent(configContentWithImports);
+};
+const writeConfigContent = (content) => {
+    const spinner = ora().start(`Updating mgnl.config.js`);
+    try {
+        fs.writeFileSync(getLocalConfigPath(), js_beautify(content.trim(), BEAUTIFY_OPTIONS), 'utf-8');
+    }
+    catch (e) {
+        spinner.stop();
+        logger === null || logger === void 0 ? void 0 : logger.error('Error occured while updating mgnl.config.js');
+        console.error(e);
+    }
+    spinner.stop();
+    logger === null || logger === void 0 ? void 0 : logger.info('mgnl.config.js updated');
+};

package/dist/lib/download.d.ts

@@ -0,0 +1,4 @@
+import { Bundle, Credentials } from "../types/types.js";
+export declare const downloadBundle: (bundle: Bundle, credentials: Credentials, dest: string | undefined) => Promise<string>;
+export declare const getDownloadUrl: (bundle: Bundle, credentials: Credentials) => Promise<string>;
+export declare const selectTag: (url: string, credentials: Credentials) => Promise<string>;

package/dist/lib/download.js

@@ -0,0 +1,119 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from "path";
+import fs from "fs-extra";
+import axios from "axios";
+import ProgressBar from "progress";
+import inquirer from "inquirer";
+import { logger } from "../jumpstart-plugin.js";
+export const downloadBundle = (bundle, credentials, dest) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let url = bundle.url;
+        const downloadDest = dest ? dest : "./download-" + new Date().getTime();
+        let downloadUrl;
+        if (path.parse(url).name === "tags") {
+            downloadUrl = yield selectTag(url, credentials);
+        }
+        else if (url.includes('https://nexus.magnolia-cms.com/service/rest/v1/search')) {
+            downloadUrl = yield getDownloadUrl(bundle, credentials);
+        }
+        else {
+            downloadUrl = url;
+        }
+        const opts = {
+            method: 'get',
+            responseType: 'stream',
+        };
+        if (credentials) {
+            opts.auth = credentials;
+        }
+        if (downloadDest) {
+            yield fs.ensureDir(downloadDest);
+        }
+        const tempDownload = path.join(downloadDest, bundle.name ? bundle.name : 'temp-' + new Date().getTime());
+        const target = fs.createWriteStream(tempDownload);
+        logger === null || logger === void 0 ? void 0 : logger.info("Starting download from: " + downloadUrl);
+        const res = yield axios.get(downloadUrl, opts);
+        if (res.headers['content-length']) {
+            const len = parseInt(res.headers['content-length'], 10);
+            const bar = new ProgressBar('Downloading [:bar] :percent :etas', {
+                complete: '=',
+                incomplete: ' ',
+                width: 20,
+                total: len
+            });
+            res.data.on('data', (chunk) => {
+                bar.tick(chunk.length);
+            });
+        }
+        res.data.pipe(target);
+        res.data.on('error', (error) => {
+            throw new Error(error);
+        });
+        return new Promise((resolve) => {
+            res.data.on('end', () => {
+                logger === null || logger === void 0 ? void 0 : logger.info("Download finished");
+                resolve(path.join('.', tempDownload));
+            });
+        });
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+});
+export const getDownloadUrl = (bundle, credentials) => __awaiter(void 0, void 0, void 0, function* () {
+    const opts = {
+        method: 'get',
+        responseType: 'json',
+        headers: {
+            Accept: 'application/json'
+        }
+    };
+    if (credentials && credentials.username && credentials.password) {
+        opts.auth = credentials;
+    }
+    try {
+        const response = yield axios.get(bundle.url + '&prerelease=false', opts);
+        const params = new URLSearchParams(bundle.url.split("?")[1]);
+        let downloadUrl = response.data.items[0].downloadUrl;
+        downloadUrl = downloadUrl === null || downloadUrl === void 0 ? void 0 : downloadUrl.split('/magnolia.');
+        downloadUrl = downloadUrl && `${downloadUrl[0]}/${params.get('repository')}/${response.data.items[0].path}`;
+        return downloadUrl;
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+});
+export const selectTag = (url, credentials) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const opts = {
+        method: 'get',
+        headers: {
+            Accept: 'application/json'
+        }
+    };
+    if (credentials && credentials.username && credentials.password) {
+        opts.auth = credentials;
+    }
+    const res = yield axios.get(url, opts);
+    if (!((_a = res.data) === null || _a === void 0 ? void 0 : _a.values) || res.data.values.length <= 0) {
+        throw new Error("There are no available tags");
+    }
+    const { tag } = yield inquirer
+        .prompt([
+        {
+            type: 'rawlist',
+            name: 'tag',
+            message: 'Please select a tag',
+            choices: res.data.values.map((tag) => ({ name: tag.displayId, value: "archive?at=" + tag.id }))
+        }
+    ]);
+    return url.slice(0, url.length - 4) + tag;
+});

package/dist/lib/extract.d.ts

@@ -0,0 +1,4 @@
+import { Bundle } from "../types/types.js";
+export declare const extract: (bundle: Bundle, file: string, command: string) => Promise<void>;
+export declare const extractApacheTomcat: (dest: string, unzipFolder: string) => Promise<void>;
+export declare const findExtractedApacheTomcatDir: (p: string) => Promise<unknown>;

package/dist/lib/extract.js

@@ -0,0 +1,54 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import decompress from "decompress";
+import path from "path";
+import walk from "walk";
+import fs from "fs-extra";
+import { PostCommands } from "../types/types.js";
+import url from "url";
+import { logger } from "../jumpstart-plugin.js";
+export const extract = (bundle, file, command) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    logger === null || logger === void 0 ? void 0 : logger.info('Extracting...');
+    const { dest = "./", type } = bundle;
+    const unzipFolder = "temp-" + new Date().getTime();
+    yield decompress(file, unzipFolder);
+    if (command === PostCommands.ExtractAndOverride) {
+        fs.rmSync(dest, { recursive: true, force: true });
+    }
+    const artifactId = (_a = url.parse(bundle.url, true)) === null || _a === void 0 ? void 0 : _a.query['maven.artifactId'];
+    if (artifactId === 'magnolia-tomcat-barebone') {
+        yield extractApacheTomcat(dest, unzipFolder);
+    }
+    else {
+        fs.copySync(unzipFolder, dest, { overwrite: true });
+    }
+    fs.rmSync(unzipFolder, { recursive: true, force: true });
+    fs.rmSync(path.dirname(file), { recursive: true, force: true });
+});
+export const extractApacheTomcat = (dest, unzipFolder) => __awaiter(void 0, void 0, void 0, function* () {
+    const apacheTomcatDir = yield findExtractedApacheTomcatDir(unzipFolder);
+    fs.rmSync(path.join(apacheTomcatDir, 'webapps', 'magnoliaAuthor'), { recursive: true, force: true });
+    fs.copySync(apacheTomcatDir, path.join(dest, "apache-tomcat"), { overwrite: false });
+});
+export const findExtractedApacheTomcatDir = (p) => {
+    return new Promise((resolve, reject) => {
+        const walker = walk.walk(p, { followLinks: false });
+        walker.on('directory', (root, { name }, next) => {
+            if (name.match(/(apache-tomcat).*/)) {
+                resolve(path.join(root, name));
+            }
+            next();
+        });
+        walker.on('end', function () {
+            return reject(new Error("apache-tomcat was not found."));
+        });
+    });
+};

package/dist/lib/helper.d.ts

@@ -0,0 +1,10 @@
+import { PluginRequirement } from "../types/types.js";
+export declare const handleLightModulesFolder: () => Promise<void>;
+export declare const findLightModulesFolder: (p: string) => Promise<unknown>;
+export declare const findWebAppsList: (apacheTomcatPath: string) => string[];
+export declare const installAdditionalPlugins: (plugins: Array<PluginRequirement>) => Promise<void>;
+export declare const initializeNodeProject: () => Promise<void>;
+export declare const installPackage: (packageManager: string, packageReference: string, packageName?: string) => Promise<boolean>;
+export declare const isValidURL: (str: string) => boolean;
+export declare const extractRepoName: (gitUrl: string) => string | null;
+export declare const determinePackageManager: (baseDirectory?: string) => "yarn" | "npm";

package/dist/lib/helper.js

@@ -0,0 +1,154 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { handleMGNLConfigFile, installAndConfigPlugins } from "./config-helper.js";
+import { handlePackageJSON } from "./pj-helper.js";
+import ora from "ora";
+import { execa } from "execa";
+import path from "path";
+import fs from "fs-extra";
+import { findExtractedApacheTomcatDir } from "./extract.js";
+import walk from "walk";
+import { logger } from "../jumpstart-plugin.js";
+export const handleLightModulesFolder = () => __awaiter(void 0, void 0, void 0, function* () {
+    let lightModulesPath;
+    try {
+        lightModulesPath = (yield findLightModulesFolder(process.cwd()));
+        logger === null || logger === void 0 ? void 0 : logger.info(`Found existing light-modules path at '${lightModulesPath}'`);
+    }
+    catch (e) {
+        logger === null || logger === void 0 ? void 0 : logger.info(`No light-modules folder found. Attempting to create one.`);
+        lightModulesPath = path.join(process.cwd(), 'light-modules');
+        try {
+            fs.mkdirSync(lightModulesPath, { recursive: true });
+            logger === null || logger === void 0 ? void 0 : logger.info(`'light-modules' folder created at '${lightModulesPath}'.`);
+        }
+        catch (error) {
+            logger === null || logger === void 0 ? void 0 : logger.error(`Failed to create 'light-modules' folder: ${error instanceof Error ? error.message : ""}`);
+            return;
+        }
+    }
+    const apacheTomcatPath = yield findExtractedApacheTomcatDir(process.cwd());
+    const webApps = findWebAppsList(apacheTomcatPath);
+    for (const webApp of webApps) {
+        const lightModulesPathToMagnoliaHomeRelPath = process.platform === 'win32' ? path.relative(webApp, lightModulesPath).replace(/\\/g, '/') : path.relative(webApp, lightModulesPath);
+        const props = {
+            'magnolia.resources.dir': '${magnolia.home}/' + lightModulesPathToMagnoliaHomeRelPath,
+            'magnolia.update.auto': "true"
+        };
+        if (webApp.endsWith("magnoliaAuthor")) {
+            props['magnolia.develop'] = "true";
+        }
+        const webAppPropertiesFilePath = path.join(webApp, 'WEB-INF', 'config', 'default', 'magnolia.properties');
+        editProperties(webAppPropertiesFilePath, props);
+    }
+});
+const editProperties = (filePath, props) => {
+    if (!fs.existsSync(filePath)) {
+        logger === null || logger === void 0 ? void 0 : logger.warn(`File ${filePath} doesn't exists, skipping configuration.`);
+        return;
+    }
+    const propertiesFileContent = fs.readFileSync(filePath, 'utf-8');
+    const replacedContent = replaceInConfig(propertiesFileContent, props);
+    try {
+        fs.writeFileSync(filePath, replacedContent);
+        Object.keys(props).forEach((key) => {
+            logger === null || logger === void 0 ? void 0 : logger.info(`Setting ${key} to: ${props[key]} in ${filePath}`);
+        });
+    }
+    catch (error) {
+        logger === null || logger === void 0 ? void 0 : logger.error(`An error occurred while updating 'magnolia.properties': ${error instanceof Error ? error.message : ""}`);
+    }
+};
+const replaceInConfig = (config, props) => {
+    Object.keys(props).forEach((key) => {
+        const regex = '(' + key.replace(/\./g, '\\.') + ')(\s*=\s*)(.+)'; // eslint-disable-line no-useless-escape
+        const replacement = '$1$2' + props[key];
+        config = config.replace(new RegExp(regex), replacement);
+    });
+    return config;
+};
+export const findLightModulesFolder = (p) => {
+    return new Promise((resolve, reject) => {
+        const walker = walk.walk(p, { followLinks: false });
+        walker.on('directory', (root, { name }, next) => {
+            if (name.match(/(light-modules)/)) {
+                resolve(path.join(root, name));
+            }
+            next();
+        });
+        walker.on('end', function () {
+            return reject(new Error("light-modules was not found."));
+        });
+    });
+};
+export const findWebAppsList = (apacheTomcatPath) => {
+    let webApps = [];
+    const webAppsFolder = path.join(apacheTomcatPath, 'webapps');
+    const files = fs.readdirSync(webAppsFolder);
+    for (const file of files) {
+        const filePath = path.join(webAppsFolder, file);
+        if (fs.statSync(filePath).isDirectory()) {
+            webApps.push(filePath);
+        }
+    }
+    return webApps;
+};
+export const installAdditionalPlugins = (plugins) => __awaiter(void 0, void 0, void 0, function* () {
+    yield installAndConfigPlugins(plugins);
+});
+export const initializeNodeProject = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield handlePackageJSON();
+    yield handleMGNLConfigFile();
+});
+export const installPackage = (packageManager, packageReference, packageName) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!packageName) {
+        packageName = packageReference;
+    }
+    const spinner = ora().start(`Installing ${packageName}`);
+    try {
+        yield execa(packageManager, [packageManager === 'npm' ? 'install' : 'add', packageReference], {
+            buffer: true,
+            cwd: process.cwd()
+        });
+        spinner.stop();
+        logger === null || logger === void 0 ? void 0 : logger.info(`${packageName} installed`);
+        return true;
+    }
+    catch (error) {
+        spinner.stop();
+        logger === null || logger === void 0 ? void 0 : logger.error(`Failed to install ${packageName}`);
+        return false;
+    }
+});
+export const isValidURL = (str) => {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+};
+export const extractRepoName = (gitUrl) => {
+    const match = gitUrl.match(/\/([^/]+?)(?:\.git)?$/);
+    return match ? match[1] : null;
+};
+export const determinePackageManager = (baseDirectory = process.cwd()) => {
+    const yarnLockPath = path.join(baseDirectory, 'yarn.lock');
+    const packageLockPath = path.join(baseDirectory, 'package-lock.json');
+    if (fs.existsSync(yarnLockPath)) {
+        return 'yarn';
+    }
+    else if (fs.existsSync(packageLockPath)) {
+        return 'npm';
+    }
+    // Default to npm
+    return 'npm';
+};

package/dist/lib/install.d.ts

@@ -0,0 +1,2 @@
+import { Bundle } from "../types/types.js";
+export declare const installDependencies: (bundle: Bundle, command: string) => Promise<void>;

package/dist/lib/install.js

@@ -0,0 +1,29 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PostCommands } from "../types/types.js";
+import path from "path";
+import { execa } from "execa";
+import ora from 'ora';
+import { logger } from "../jumpstart-plugin.js";
+export const installDependencies = (bundle, command) => __awaiter(void 0, void 0, void 0, function* () {
+    const spinner = ora('Installing dependencies').start();
+    try {
+        yield execa(command === PostCommands.YarnInstall ? 'yarn' : 'npm', ['install'], {
+            buffer: true,
+            cwd: path.join(process.cwd(), bundle.dest ? bundle.dest : "./")
+        });
+        spinner.stop();
+        logger === null || logger === void 0 ? void 0 : logger.info('Dependencies installed');
+    }
+    catch (e) {
+        spinner.stop();
+        logger === null || logger === void 0 ? void 0 : logger.error('Failed to install dependencies');
+    }
+});

package/dist/lib/pj-helper.d.ts

@@ -0,0 +1,3 @@
+export declare const handlePackageJSON: () => Promise<void>;
+export declare const modifyPackageJSON: (pjPath: string) => Promise<void>;
+export declare const initPackageJSON: () => Promise<void>;

package/dist/lib/pj-helper.js

@@ -0,0 +1,91 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from "path";
+import ora from "ora";
+import fs from "fs-extra";
+import { execa } from "execa";
+import { determinePackageManager, installPackage } from "./helper.js";
+import { logger } from "../jumpstart-plugin.js";
+export const handlePackageJSON = () => __awaiter(void 0, void 0, void 0, function* () {
+    const pjPath = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(pjPath)) {
+        yield initPackageJSON();
+    }
+    yield modifyPackageJSON(pjPath);
+});
+export const modifyPackageJSON = (pjPath) => __awaiter(void 0, void 0, void 0, function* () {
+    let pj = JSON.parse(fs.readFileSync(pjPath, 'utf8'));
+    let isMgnlCliInstalled = (pj === null || pj === void 0 ? void 0 : pj.dependencies) && (pj === null || pj === void 0 ? void 0 : pj.dependencies['@magnolia/cli']);
+    if (!isMgnlCliInstalled) {
+        isMgnlCliInstalled = yield installPackage(determinePackageManager(), "@magnolia/cli@preview", "mgnl-cli");
+        if (isMgnlCliInstalled) {
+            pj = JSON.parse(fs.readFileSync(pjPath, 'utf8'));
+        }
+    }
+    const nodeModulesPath = path.join(process.cwd(), "node_modules");
+    if (!fs.existsSync(nodeModulesPath)) {
+        const npmISpinner = ora().start("Didn't find 'node_modules' folder. Running 'npm install'");
+        try {
+            yield execa(determinePackageManager(), ["install"], {
+                buffer: true,
+                cwd: process.cwd()
+            });
+        }
+        catch (e) {
+            npmISpinner.stop();
+            logger === null || logger === void 0 ? void 0 : logger.error("'npm install' has failed");
+            return;
+        }
+        npmISpinner.stop();
+        logger === null || logger === void 0 ? void 0 : logger.info("Running 'npm install' done");
+    }
+    if (isMgnlCliInstalled) {
+        const mgnlScript = { "mgnl": "node node_modules/@magnolia/cli" };
+        const scriptKey = Object.keys(mgnlScript)[0];
+        if (!pj.scripts) {
+            pj.scripts = {};
+        }
+        if (!pj.scripts[scriptKey] || pj.scripts[scriptKey] !== mgnlScript[scriptKey]) {
+            logger === null || logger === void 0 ? void 0 : logger.info('Add "mgnl" script to package.json');
+            pj.scripts[scriptKey] = mgnlScript[scriptKey];
+        }
+    }
+    if (!pj.type) {
+        pj.type = "module";
+    }
+    else if (pj.type !== "module") {
+        logger === null || logger === void 0 ? void 0 : logger.warn(`Changing 'type' to "module"`);
+        pj.type = "module";
+    }
+    try {
+        fs.writeFileSync(pjPath, JSON.stringify(pj, null, '\t'), 'utf8');
+    }
+    catch (e) {
+        logger === null || logger === void 0 ? void 0 : logger.error('Failed to modify package.json');
+        return;
+    }
+});
+export const initPackageJSON = () => __awaiter(void 0, void 0, void 0, function* () {
+    const pjSpinner = ora().start('Creating package.json');
+    try {
+        yield execa(determinePackageManager(), ['init', '-y'], {
+            buffer: true,
+            cwd: process.cwd()
+        });
+    }
+    catch (e) {
+        pjSpinner.stop();
+        logger === null || logger === void 0 ? void 0 : logger.info('Failed to create package.json');
+        console.error(e);
+        return;
+    }
+    pjSpinner.stop();
+    logger === null || logger === void 0 ? void 0 : logger.info('package.json created');
+});

package/dist/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@magnolia/cli-jumpstart-plugin",
+  "version": "1.0.0-preview.1",
+  "description": "Plugin to set up new projects using predefined templates and bundles. Easily select and configure project templates, and let the plugin handle bundle downloads, extraction, and post-command execution.",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "build": "standard && tsc && cpy package.json dist",
+    "standard": "npx standard"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@jest/globals": "^29.6.3",
+    "@types/decompress": "^4.2.4",
+    "@types/fs-extra": "^11.0.1",
+    "@types/inquirer": "^9.0.3",
+    "@types/js-beautify": "^1.14.0",
+    "@types/node": "^20.3.3",
+    "@types/progress": "^2.0.5",
+    "@types/walk": "^2.3.1",
+    "@types/yauzl": "^2.10.1",
+    "cpy-cli": "^5.0.0",
+    "jest": "^29.6.2",
+    "standard": "^17.1.0",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@magnolia/cli-plugin-template": "^1.1.0",
+    "axios": "^1.4.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "decompress": "^4.2.1",
+    "dotenv": "^16.3.1",
+    "execa": "^7.2.0",
+    "fs-extra": "^11.1.1",
+    "inquirer": "^9.2.8",
+    "js-beautify": "^1.14.9",
+    "ora": "^7.0.1",
+    "progress": "^2.0.3",
+    "walk": "^2.3.15",
+    "winston": "^3.10.0"
+  },
+  "type": "module",
+  "standard": {
+    "ignore": [
+      "tests/resources/config-helper/*/mgnl.config.js"
+    ]
+  }
+}

package/dist/types/types.d.ts

@@ -0,0 +1,69 @@
+export interface PluginOptions {
+    template: string | boolean;
+    projectTemplatesPath: string;
+}
+export interface Bundle {
+    url: string;
+    auth?: string | boolean;
+    postCommand: Array<string>;
+    type?: string;
+    dest?: string;
+    downloadDest?: string;
+    name?: string;
+}
+export interface TemplateBase {
+    name: string;
+    auth?: boolean;
+}
+export interface TemplateWithChildren extends TemplateBase {
+    children: Array<Template>;
+    bundles?: never;
+    plugins?: never;
+}
+export interface TemplateWithBundles extends TemplateBase {
+    bundles: Array<Bundle>;
+    children?: never;
+    plugins?: never;
+}
+export interface TemplateWithPlugins extends TemplateBase {
+    plugins: Array<PluginRequirement>;
+    bundles?: never;
+    children?: never;
+}
+export interface TemplateWithBundlesAndPlugins extends TemplateBase {
+    bundles: Array<Bundle>;
+    plugins: Array<PluginRequirement>;
+    children?: never;
+}
+export type TemplateWithoutChildren = TemplateWithBundles | TemplateWithPlugins | TemplateWithBundlesAndPlugins;
+export type Template = TemplateWithChildren | TemplateWithoutChildren;
+export interface PluginRequirement {
+    name: string;
+    installReference: string;
+}
+export type Credentials = {
+    username: string;
+    password: string;
+} | null;
+export declare enum PostCommands {
+    Extract = "extract",
+    ExtractAndOverride = "extract and override",
+    NpmInstall = "npm install",
+    YarnInstall = "yarn install"
+}
+export interface PluginRequirement {
+    name: string;
+    installReference: string;
+}
+export type ImportItem = {
+    importedNames: string;
+    importSource: string;
+};
+export interface CommandItem {
+    commandName: string;
+}
+export type ParsedConfigData = {
+    configContent: string;
+    imports: ImportItem[];
+    commands: CommandItem[];
+};

package/dist/types/types.js

@@ -0,0 +1,7 @@
+export var PostCommands;
+(function (PostCommands) {
+    PostCommands["Extract"] = "extract";
+    PostCommands["ExtractAndOverride"] = "extract and override";
+    PostCommands["NpmInstall"] = "npm install";
+    PostCommands["YarnInstall"] = "yarn install";
+})(PostCommands || (PostCommands = {}));

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@magnolia/cli-jumpstart-plugin",
+  "version": "1.0.0-preview.1",
+  "description": "Plugin to set up new projects using predefined templates and bundles. Easily select and configure project templates, and let the plugin handle bundle downloads, extraction, and post-command execution.",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "build": "standard && tsc && cpy package.json dist",
+    "standard": "npx standard"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@jest/globals": "^29.6.3",
+    "@types/decompress": "^4.2.4",
+    "@types/fs-extra": "^11.0.1",
+    "@types/inquirer": "^9.0.3",
+    "@types/js-beautify": "^1.14.0",
+    "@types/node": "^20.3.3",
+    "@types/progress": "^2.0.5",
+    "@types/walk": "^2.3.1",
+    "@types/yauzl": "^2.10.1",
+    "cpy-cli": "^5.0.0",
+    "jest": "^29.6.2",
+    "standard": "^17.1.0",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@magnolia/cli-plugin-template": "^1.1.0",
+    "axios": "^1.4.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "decompress": "^4.2.1",
+    "dotenv": "^16.3.1",
+    "execa": "^7.2.0",
+    "fs-extra": "^11.1.1",
+    "inquirer": "^9.2.8",
+    "js-beautify": "^1.14.9",
+    "ora": "^7.0.1",
+    "progress": "^2.0.3",
+    "walk": "^2.3.15",
+    "winston": "^3.10.0"
+  },
+  "type": "module",
+  "standard": {
+    "ignore": [
+      "tests/resources/config-helper/*/mgnl.config.js"
+    ]
+  }
+}