@scandipwa/magento-scripts 2.4.0-alpha.1 → 2.4.0-alpha.3

package/lib/tasks/magento/install-magento-project.js

@@ -9,6 +9,11 @@ const getJsonFileData = require('../../util/get-jsonfile-data')
 const KnownError = require('../../errors/known-error')
 const UnknownError = require('../../errors/unknown-error')
 const { runPHPContainerCommand } = require('../php/php-container')
+const {
+    setupMagentoFilePermissions,
+    setupComposerCachePermissions
+} = require('./setup-magento/setup-file-permissions')
+const makeBinariesExecutable = require('./setup-magento/make-magento-binaries-executable')
 
 const magentoProductEnterpriseEdition = 'magento/product-enterprise-edition'
 const magentoProductCommunityEdition = 'magento/product-community-edition'
@@ -59,7 +64,8 @@ const adjustComposerJson = async (
                     ? undefined
                     : (t) => {
                           task.output = t
-                      }
+                      },
+                useAutomaticUser: true
             }
         )
     }
@@ -154,6 +160,46 @@ mv ${tempDir}/composer.json ${
     )
 }
 
+/**
+ * Will check if the following conditions are met:
+ * - composer.lock file exists
+ * - vendor directory exists
+ * - all packages from composer.lock are installed in vendor directory
+ * @param {string} magentoDir
+ */
+const getIsVendorFolderCorrupted = async (magentoDir) => {
+    const composerLockFile = path.join(magentoDir, 'composer.lock')
+    const vendorDir = path.join(magentoDir, 'vendor')
+    const [vendorDirStat, composerLockFileStat] = await Promise.all([
+        pathExists(vendorDir),
+        pathExists(composerLockFile)
+    ])
+    if (!vendorDirStat || !composerLockFileStat) {
+        return true
+    }
+    /**
+     * @type {{ packages: { name: string }[] } | null}
+     */
+    const composerLockData = await getJsonFileData(composerLockFile)
+    if (!composerLockData || !composerLockData.packages) {
+        return true
+    }
+    const { packages } = composerLockData
+    const packagesNames = packages.map((pkg) => pkg.name)
+
+    const hasCorruptPackages = await Promise.all(
+        packagesNames.map(async (pkg) => {
+            const vendorPackage = path.join(vendorDir, pkg)
+            const composerJson = path.join(vendorPackage, 'composer.json')
+            if (!(await pathExists(composerJson))) {
+                return true
+            }
+        })
+    )
+
+    return hasCorruptPackages.every((result) => result === true)
+}
+
 /**
  * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
@@ -191,7 +237,11 @@ const installMagentoProject = () => ({
             'composer.lock': true
         })
 
-        if (isFsMatching) {
+        const isVendorFolderCorrupted = await getIsVendorFolderCorrupted(
+            baseConfig.magentoDir
+        )
+
+        if (isFsMatching && !isVendorFolderCorrupted) {
             ctx.magentoFirstInstall = false
             task.skip()
             return
@@ -200,43 +250,60 @@ const installMagentoProject = () => ({
         task.title = `Installing Magento ${magentoPackageVersion}`
         task.output = `Creating Magento ${magentoPackageVersion} project`
 
-        if (!(await pathExists(path.join(process.cwd(), 'composer.json')))) {
-            await createMagentoProject(ctx, task, {
-                magentoProject,
-                magentoPackageVersion
-            })
-        }
-
-        if (!(await pathExists(path.join(process.cwd(), 'app', 'etc')))) {
-            await fs.promises.mkdir(path.join(process.cwd(), 'app', 'etc'), {
-                recursive: true
-            })
-        }
-
-        try {
-            await runComposerCommand(ctx, 'install', {
-                callback: !ctx.verbose
-                    ? undefined
-                    : (t) => {
-                          task.output = t
-                      }
-            })
-        } catch (e) {
+        if (!isFsMatching) {
             if (
-                e instanceof UnknownError &&
-                e.message.includes('man-in-the-middle attack')
+                !(await pathExists(path.join(process.cwd(), 'composer.json')))
             ) {
-                throw new KnownError(`Probably you haven't setup pubkeys in composer.
-        Please run ${logger.style.command(
-            'composer diagnose'
-        )} in cli to get mode.\n\n${e}`)
+                await createMagentoProject(ctx, task, {
+                    magentoProject,
+                    magentoPackageVersion
+                })
             }
 
-            throw new UnknownError(
-                `Unexpected error during composer install.\n\n${e}`
-            )
+            if (!(await pathExists(path.join(process.cwd(), 'app', 'etc')))) {
+                await fs.promises.mkdir(
+                    path.join(process.cwd(), 'app', 'etc'),
+                    {
+                        recursive: true
+                    }
+                )
+            }
         }
-        ctx.magentoFirstInstall = true
+
+        return task.newListr([
+            setupMagentoFilePermissions(),
+            setupComposerCachePermissions(),
+            {
+                title: 'Installing Magento dependencies',
+                task: async () => {
+                    try {
+                        await runComposerCommand(ctx, 'install -vvv', {
+                            callback: !ctx.verbose
+                                ? undefined
+                                : (t) => {
+                                      task.output = t
+                                  }
+                        })
+                    } catch (e) {
+                        if (
+                            e instanceof UnknownError &&
+                            e.message.includes('man-in-the-middle attack')
+                        ) {
+                            throw new KnownError(`Probably you haven't setup pubkeys in composer.
+                    Please run ${logger.style.command(
+                        'composer diagnose'
+                    )} in cli to get mode.\n\n${e}`)
+                        }
+
+                        throw new UnknownError(
+                            `Unexpected error during composer install.\n\n${e}`
+                        )
+                    }
+                    ctx.magentoFirstInstall = true
+                }
+            },
+            makeBinariesExecutable()
+        ])
     },
     options: {
         bottomBar: 10

package/lib/tasks/magento/setup-magento/check-file-permissions.php

@@ -0,0 +1,55 @@
+<?php
+// receive directories from command line arguments
+$directories = explode(",", $argv[1]);
+
+$results = [];
+
+foreach ($directories as $directory) {
+    $result = [];
+    $result['directory'] = $directory;
+    $result['exists'] = file_exists($directory);
+    $result['writable'] = is_writable($directory);
+    $result['readable'] = is_readable($directory);
+
+    if ($result['exists']) {
+        $result['owner'] = posix_getpwuid(fileowner($directory));
+        $result['group'] = posix_getgrgid(filegroup($directory));
+        $result['current_user'] = posix_getpwuid(posix_geteuid());
+
+        // Check if current user is in the group
+        if ($result['group']['members'] && is_array($result['group']['members'])) {
+            $result['current_user_in_group'] = in_array($result['current_user']['name'], $result['group']['members']);
+        } else {
+            $result['current_user_in_group'] = false;
+        }
+
+        // Check if the directory has group write permissions (g+w)
+        $permissions = fileperms($directory);
+        $result['has_group_write_permissions'] = ($permissions & 0x0010) !== 0;
+
+        $result['permissions'] = substr(sprintf('%o', fileperms($directory)), -4);
+        $result['is_current_user_directory_owner'] = $result['current_user'] === $result['owner'];
+
+        if ($result['writable']) {
+            // Check if new files inherit the directory's group
+            try {
+                $tempFile = $directory . DIRECTORY_SEPARATOR . '.temp_file_' . uniqid();
+                touch($tempFile);
+
+                $tempFileGroup = posix_getgrgid(filegroup($tempFile));
+                $result['new_files_inherit_group'] = $tempFileGroup === $result['group'];
+            } catch (Exception $e) {
+                $result['new_files_inherit_group'] = false;
+            } finally {
+                // Clean up the temporary file
+                if (file_exists($tempFile)) {
+                    unlink($tempFile);
+                }
+            }
+        }
+    }
+
+    $results[] = $result;
+}
+
+echo json_encode($results, JSON_PRETTY_PRINT);

package/lib/tasks/magento/setup-magento/disable-custom-admin-path.js

@@ -0,0 +1,21 @@
+const { deleteTableValues } = require('../../../util/database')
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const disableCustomAdminPath = () => ({
+    title: 'Disabling custom admin path',
+    task: async ({ databaseConnection }, task) => {
+        await deleteTableValues(
+            'core_config_data',
+            [
+                {
+                    path: 'admin/url/use_custom_path'
+                }
+            ],
+            { databaseConnection, task }
+        )
+    }
+})
+
+module.exports = disableCustomAdminPath

package/lib/tasks/magento/setup-magento/disable-maintenance-mode.js

@@ -1,3 +1,5 @@
+const path = require('path')
+const pathExists = require('../../../util/path-exists')
 const runMagentoCommand = require('../../../util/run-magento')
 
 /**
@@ -6,6 +8,17 @@ const runMagentoCommand = require('../../../util/run-magento')
 const disableMaintenanceMode = () => ({
     title: 'Disabling maintenance mode',
     task: async (ctx, task) => {
+        const maintenanceModeFile = `var/.maintenance.flag`
+
+        if (
+            !(await pathExists(
+                path.join(ctx.config.baseConfig.magentoDir, maintenanceModeFile)
+            ))
+        ) {
+            task.skip()
+            return
+        }
+
         const { result } = await runMagentoCommand(ctx, 'maintenance:status', {
             throwNonZeroCode: false
         })

package/lib/tasks/magento/setup-magento/index.js

@@ -13,6 +13,7 @@ const urnHighlighter = require('./urn-highlighter')
 const adjustFullPageCache = require('./adjust-full-page-cache')
 const updateEnvPHP = require('../../php/update-env-php')
 const setMailConfig = require('./set-mail-config')
+const { setupMagentoFilePermissions } = require('./setup-file-permissions')
 
 /**
  * @param {Object} [options]
@@ -34,6 +35,7 @@ const setupMagento = (options = {}) => ({
         return task.newListr(
             [
                 waitingForRedis(),
+                setupMagentoFilePermissions(),
                 updateEnvPHP(),
                 migrateDatabase(),
                 flushRedisConfig(),

package/lib/tasks/magento/setup-magento/make-magento-binaries-executable.js

@@ -0,0 +1,44 @@
+// Yes, I know binary files are files in binary format, but this is a common term for executable files
+
+const fs = require('fs')
+const path = require('path')
+const pathExists = require('../../../util/path-exists')
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeBinariesExecutable = () => ({
+    task: async (ctx, task) => {
+        const directoriesWithBinFiles = [
+            path.join(ctx.config.baseConfig.magentoDir, 'bin'),
+            path.join(ctx.config.baseConfig.magentoDir, 'vendor', 'bin')
+        ]
+
+        for (const directory of directoriesWithBinFiles) {
+            if (!(await pathExists(directory))) {
+                continue
+            }
+            const files = await fs.promises.readdir(directory, {
+                withFileTypes: true
+            })
+
+            for (const file of files) {
+                if (!file.isFile()) {
+                    continue
+                }
+
+                const filePath = path.join(directory, file.name)
+                const stats = await fs.promises.stat(filePath)
+
+                if (!filePath.startsWith(file.name) && stats.mode & 0o111) {
+                    continue
+                }
+
+                task.output = `Making ${filePath} executable`
+                await fs.promises.chmod(filePath, 0o755)
+            }
+        }
+    }
+})
+
+module.exports = makeBinariesExecutable

package/lib/tasks/magento/setup-magento/set-deployment-mode.js

@@ -1,5 +1,5 @@
+const envPhpToJson = require('../../../util/env-php-json')
 const magentoTask = require('../../../util/magento-task')
-const runMagentoCommand = require('../../../util/run-magento')
 
 /**
  * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
@@ -12,11 +12,14 @@ module.exports = () => ({
                 magentoConfiguration: { mode }
             }
         } = ctx
-        const { result } = await runMagentoCommand(ctx, 'deploy:mode:show', {
-            throwNonZeroCode: false
-        })
+        const envPhpData = await envPhpToJson(ctx)
+        if (!envPhpData) {
+            task.skip()
+            return
+        }
+        const { MAGE_MODE } = envPhpData
 
-        if (result.includes(mode)) {
+        if (MAGE_MODE === mode) {
             task.skip()
             return
         }

package/lib/tasks/magento/setup-magento/set-mail-config.js

@@ -10,14 +10,28 @@ const setMailConfig = () => ({
             'core_config_data',
             [
                 {
-                    path: 'smtp/configuration_option/port',
+                    path: 'system/smtp/transport',
+                    value: 'smtp'
+                },
+                {
+                    path: 'system/smtp/host',
+                    value: isDockerDesktop
+                        ? 'host.docker.internal'
+                        : '127.0.0.1'
+                },
+                {
+                    path: 'system/smtp/port',
                     value: `${ports.maildevSMTP}`
                 },
                 {
                     path: 'smtp/configuration_option/host',
                     value: isDockerDesktop
                         ? 'host.docker.internal'
-                        : 'localhost'
+                        : '127.0.0.1'
+                },
+                {
+                    path: 'smtp/configuration_option/port',
+                    value: `${ports.maildevSMTP}`
                 }
             ],
             { databaseConnection, task }

package/lib/tasks/magento/setup-magento/setup-file-permissions.js

@@ -0,0 +1,236 @@
+const os = require('os')
+const fs = require('fs')
+const path = require('path')
+const {
+    runPHPContainerCommandTask,
+    runPHPContainerCommand
+} = require('../../php/php-container')
+
+const directoriesToCheck = [
+    'var',
+    'generated',
+    'vendor',
+    'pub/media',
+    'pub/static',
+    'app/etc'
+]
+
+/**
+ * @param {string[]} directories
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeNewFilesCreatedInFolderUseDirectoryGroup = (directories) => ({
+    title: 'Make new files created in folder use directory group',
+    task: async (ctx, task) => {
+        if (directories.length === 0) {
+            task.skip()
+            return
+        }
+
+        return task.newListr([
+            runPHPContainerCommandTask(
+                `find ${directories.join(' ')} -type d -exec chmod g+ws {} +`,
+                {
+                    // should prevent command from failing the task
+                    // if the folder does not exist
+                    withCode: true,
+                    useAutomaticUser: false
+                }
+            )
+        ])
+    }
+})
+
+/**
+ * @param {string[]} directories
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeFilesWritableForGroupMembers = (directories) => ({
+    title: 'Make files writable for group members',
+    task: async (ctx, task) => {
+        if (directories.length === 0) {
+            task.skip()
+            return
+        }
+
+        return task.newListr([
+            runPHPContainerCommandTask(
+                `find ${directories.join(
+                    ' '
+                )} -type -type f -exec chmod g+w {} +`,
+                {
+                    // should prevent command from failing the task
+                    // if the folder does not exist
+                    withCode: true
+                }
+            )
+        ])
+    }
+})
+
+/**
+ * @param {string} folder
+ * @param {string | number} user
+ * @param {string | number} [group]
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeFolderOwnedByUser = (folder, user, group) => ({
+    title: `Make folder ${folder} owned by ${user} user${
+        group ? ` and ${group} group` : ''
+    }`,
+    task: (ctx, task) =>
+        task.newListr([
+            runPHPContainerCommandTask(
+                `chown -R ${user}${group ? `:${group}` : ''} ${folder}`,
+                {
+                    user: 'root:root'
+                }
+            )
+        ])
+})
+
+/**
+ * @param {import('../../../../typings/context').ListrContext} ctx
+ * @param {string[]} directories
+ * @return {Promise<{directory: string, exists: boolean, new_files_inherit_group: boolean, has_group_write_permissions: boolean, writable: boolean, permissions: string, directory_owner: {name: string, passwd: string, uid: number, gid: number, gecos: string, dir: string, shell: string} | boolean, directory_group: boolean, current_user: {name: string, passwd: string, uid: number, gid: number, gecos: string, dir: string, shell: string} | boolean, is_current_user_directory_owner: boolean}[]>}
+ */
+const checkDirectoriesPermissions = async (ctx, directories) => {
+    const checkPHPPermissionsFileName = 'check-file-permissions.php'
+    const cacheDirFilePath = path.join(
+        ctx.config.baseConfig.cacheDir,
+        `${Date.now()}-${checkPHPPermissionsFileName}`
+    )
+    await fs.promises.copyFile(
+        path.join(__dirname, checkPHPPermissionsFileName),
+        cacheDirFilePath
+    )
+    const user =
+        ctx.platform === 'linux' ? `${os.userInfo().username}` : 'www-data'
+    const group =
+        ctx.platform === 'linux' ? `${os.userInfo().username}` : 'www-data'
+
+    const userWithGroup = `${user}:${group}`
+
+    const result = await runPHPContainerCommand(
+        ctx,
+        `php ${path.relative(
+            ctx.config.baseConfig.containerMagentoDir,
+            cacheDirFilePath
+        )} ${directories.join(',')}`,
+        {
+            user: userWithGroup,
+            cwd: ctx.config.baseConfig.containerMagentoDir
+        }
+    )
+
+    await fs.promises.unlink(cacheDirFilePath)
+
+    return JSON.parse(result)
+}
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupMagentoFilePermissions = () => ({
+    title: 'Setting Magento file permissions',
+    task: async (ctx, task) => {
+        const parsedResult = await checkDirectoriesPermissions(
+            ctx,
+            directoriesToCheck.map((directory) =>
+                path.join(ctx.config.baseConfig.containerMagentoDir, directory)
+            )
+        )
+        const nonWritableDirectories = parsedResult.filter(
+            ({ exists, writable }) => exists && !writable
+        )
+
+        const tasks = []
+
+        if (nonWritableDirectories.length !== 0) {
+            const nonWritableDirectoriesPaths = nonWritableDirectories.map(
+                ({ directory }) => directory
+            )
+            const user =
+                ctx.platform === 'linux'
+                    ? `${os.userInfo().username}`
+                    : 'www-data'
+            const group =
+                ctx.platform === 'linux'
+                    ? `${os.userInfo().username}`
+                    : 'www-data'
+
+            tasks.push(
+                makeFilesWritableForGroupMembers(nonWritableDirectoriesPaths),
+                {
+                    task: (subCtx, subTask) =>
+                        subTask.newListr(
+                            nonWritableDirectoriesPaths.map((directory) =>
+                                makeFolderOwnedByUser(directory, user, group)
+                            )
+                        ),
+                    options: {
+                        concurrent: true
+                    }
+                }
+            )
+        }
+
+        const directoriesThatNeedNewFilesInheritGroup = parsedResult
+            .filter(
+                ({ exists, new_files_inherit_group: nfig }) => exists && !nfig
+            )
+            .map(({ directory }) => directory)
+
+        if (directoriesThatNeedNewFilesInheritGroup.length > 0) {
+            tasks.push(
+                makeNewFilesCreatedInFolderUseDirectoryGroup(
+                    directoriesThatNeedNewFilesInheritGroup
+                )
+            )
+        }
+
+        if (tasks.length === 0) {
+            task.skip()
+            return
+        }
+
+        return task.newListr(tasks)
+    }
+})
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupComposerCachePermissions = () => ({
+    title: 'Setting Composer Cache permissions',
+    task: async (ctx, task) => {
+        const parsedResult = await checkDirectoriesPermissions(ctx, [
+            '/composer/home'
+        ])
+
+        if (parsedResult.every((dir) => dir.writable)) {
+            task.skip()
+            return
+        }
+
+        const userAndGroup =
+            ctx.platform === 'linux' ? `${os.userInfo().username}` : 'www-data'
+
+        return task.newListr([
+            makeFolderOwnedByUser('/composer/home', userAndGroup, userAndGroup),
+            runPHPContainerCommandTask('chmod g+ws /composer/home/cache', {
+                user: ctx.platform === 'linux' ? 'root:root' : ''
+            }),
+            runPHPContainerCommandTask('chmod g+w /composer/home/cache', {
+                user: ctx.platform === 'linux' ? 'root:root' : ''
+            })
+        ])
+    }
+})
+
+module.exports = {
+    makeFilesWritableForGroupMembers,
+    makeNewFilesCreatedInFolderUseDirectoryGroup,
+    setupMagentoFilePermissions,
+    setupComposerCachePermissions
+}

package/lib/tasks/php/php-container.js

@@ -1,11 +1,15 @@
 /* eslint-disable no-use-before-define */
+const os = require('os')
 const { deepmerge } = require('../../util/deepmerge')
 const { containerApi } = require('../docker/containers')
 
 /**
- * @type {typeof import('./php-container')['runPHPContainerCommand']}
+ * @param {Parameters<typeof import('./php-container')['runPHPContainerCommand']>[0]} ctx
+ * @param {Parameters<typeof import('./php-container')['runPHPContainerCommand']>[1]} command
+ * @param {Parameters<typeof import('./php-container')['runPHPContainerCommand']>[2] & { useAutomaticUser?: boolean}} [options]
  */
 const runPHPContainerCommand = async (ctx, command, options = {}) => {
+    const { useAutomaticUser = true } = options
     const { php } = ctx.config.docker.getContainers(ctx.ports)
 
     const containers = await containerApi.ls({
@@ -23,11 +27,21 @@ const runPHPContainerCommand = async (ctx, command, options = {}) => {
             php,
             {
                 detach: false,
-                rm: true
-            },
-            {
+                rm: true,
                 command
-            }
+            },
+            useAutomaticUser && ctx.platform === 'linux'
+                ? {
+                      user: `${os.userInfo().username}:${
+                          os.userInfo().username
+                      }`
+                  }
+                : {},
+            options.user
+                ? {
+                      user: options.user
+                  }
+                : {}
         ),
         options
     )
@@ -68,7 +82,8 @@ const execPHPContainerCommand = async (ctx, command, options = {}) => {
         {
             container: php.name,
             ...deepmerge(php, options.env ? { env: options.env } : {}),
-            command
+            command,
+            ...(options.user ? { user: options.user } : {})
         },
         options
     )