@shoper/cli 0.8.1-3 → 0.8.1-7

package/build/theme/features/theme/utils/{files_structure/theme_files_structure_utils.js → files/theme_files_utils.js}

@@ -1,4 +1,4 @@
-import { readJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { fileExists, isDirectory, readJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
 import { join, looksLikeDirectory, mapKeysPathsToWindowPlatform, toUnixPath } from '../../../../../utils/path_utils.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
 import { THEME_CURRENT_CHECKSUMS_FILE_NAME, THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME, THEME_FILES_STRUCTURE_FILE_NAME, THEME_INITIAL_CHECKSUMS_FILE_NAME, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME } from '../../theme_constants.js';
@@ -7,8 +7,8 @@ import { validateDirectory } from '../../../../utils/directory_validator/directo
 import path from 'node:path';
 import { THEME_FILES_LIST_FILE_NAME } from '../../push/theme_push_constants.js';
 import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-import { loadShoperIgnore } from '../../../../utils/shoperignore/shoperignore_utils.js';
-export class ThemeFilesStructureUtils {
+import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
+export class ThemeFilesUtils {
     static async getThemeFilesStructure(themeDirectory) {
         const filesStructure = await readJSONFile(join(themeDirectory, SHOPER_THEME_METADATA_DIR, THEME_FILES_STRUCTURE_FILE_NAME));
         if (!isWindowsOs())
@@ -20,7 +20,7 @@ export class ThemeFilesStructureUtils {
         await writeJSONFile(filePath, filesStructure);
     }
     static async getFilesPermissions(themeDirectory) {
-        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
+        const fileStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDirectory);
         return Object.entries(fileStructure).reduce((acc, [key, value]) => {
             return {
                 ...acc,
@@ -29,23 +29,32 @@ export class ThemeFilesStructureUtils {
         }, {});
     }
     static async validateThemeDirectoryStructure({ checksums, permissions, rootDirectory }) {
-        const ignoreInstance = await loadShoperIgnore(rootDirectory);
         return await validateDirectory({
             permissions,
             checksums,
-            rootDirectory,
-            ignoreInstance
+            rootDirectory
         });
     }
     static async getThemeRootDirectories(themeDirectory) {
-        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
+        const filesStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDirectory);
         return Object.keys(filesStructure).filter((path) => {
             return looksLikeDirectory(path);
         });
     }
     static mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded = {}) {
-        const mappedFilesRecords = filesRecords.reduce((acc, { fileGlob, fileName }) => {
+        let areAllSkinstoreFilesUnchanged = true;
+        const filesList = filesRecords.reduce((acc, { fileGlob, fileName, state, actionKey }) => {
             const name = localFileNameToUploaded[fileName] ?? fileName;
+            if (state === FILE_STATES.deleted && actionKey === 'thumbnail') {
+                return {
+                    ...acc,
+                    [fileGlob]: null
+                };
+            }
+            if (actionKey === 'skinstore_files' && state !== FILE_STATES.unchanged)
+                areAllSkinstoreFilesUnchanged = false;
+            if (state === FILE_STATES.deleted || (state === FILE_STATES.unchanged && actionKey !== 'skinstore_files'))
+                return acc;
             if (looksLikeDirectory(fileGlob)) {
                 const existingFiles = acc[fileGlob] || [];
                 return {
@@ -60,32 +69,31 @@ export class ThemeFilesStructureUtils {
                 };
             }
         }, {});
-        /*
-         * Brzydki fix, poprawione w partial push na ładniej
-         */
-        if (!mappedFilesRecords['settings/thumbnail.jpg']) {
-            mappedFilesRecords['settings/thumbnail.jpg'] = null;
-        }
-        return mappedFilesRecords;
+        if (areAllSkinstoreFilesUnchanged)
+            delete filesList['skinstore/files'];
+        return filesList;
     }
     static async createAFilesListFile(themeRootDir, filesList) {
         if (!filesList || !Object.keys(filesList).length)
             return;
-        const toUnixStyleFilesList = Object.entries(filesList).reduce((acc, [filePath, value]) => {
+        const toUnixStyleFilesList = {};
+        for (const [filePath, value] of Object.entries(filesList)) {
             const unixPath = toUnixPath(filePath);
-            const finalPath = looksLikeDirectory(unixPath) ? `${unixPath}${path.posix.sep}` : unixPath;
-            return {
-                ...acc,
-                [finalPath]: value
-            };
-        }, {});
-        await writeJSONFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME), toUnixStyleFilesList);
+            const finalPath = (await fileExists(join(themeRootDir, filePath))) && (await isDirectory(join(themeRootDir, filePath)))
+                ? `${unixPath}${path.posix.sep}`
+                : unixPath;
+            toUnixStyleFilesList[finalPath] = value;
+        }
+        await writeJSONFile(this.getFilesListFilePath(themeRootDir), toUnixStyleFilesList);
+    }
+    static getFilesListFilePath(themeRootDir) {
+        return join(themeRootDir, THEME_FILES_LIST_FILE_NAME);
     }
     static async removeAFilesListFile(themeRootDir) {
-        await removeFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME));
+        await removeFile(this.getFilesListFilePath(themeRootDir));
     }
     static async updateFilesStructure(themeDir) {
-        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
+        const fileStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDir);
         const checksumsFiles = [
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_FILE_NAME}`,
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME}`,
@@ -109,7 +117,7 @@ export class ThemeFilesStructureUtils {
             },
             _links: { [THEME_ACTIONS_TYPES.push]: '*' }
         };
-        ['.gitignore', '.shoperignore'].forEach((fileName) => {
+        ['.gitignore'].forEach((fileName) => {
             fileStructure[fileName] = {
                 permissions: {
                     canAdd: true,
@@ -118,6 +126,6 @@ export class ThemeFilesStructureUtils {
                 }
             };
         });
-        await ThemeFilesStructureUtils.writeThemeFilesStructure(themeDir, fileStructure);
+        await ThemeFilesUtils.writeThemeFilesStructure(themeDir, fileStructure);
     }
 }

package/build/theme/features/theme/utils/files_structure/theme_file_structure_errors_factory.js

@@ -1,9 +1 @@
-import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
-export class ThemeFileStructureErrorsFactory {
-    static createNoFilesStructureError() {
-        return new AppError({
-            code: 'theme.file_structure.no_files_structure',
-            message: 'No files structure found for the theme.'
-        });
-    }
-}
+export {};

package/build/theme/features/theme/utils/meta_data/theme_meta_data_utils.js

@@ -58,32 +58,4 @@ export class ThemeMetaDataUtils {
             });
         });
     }
-    static async createShoperIgnoreFile(themeDir) {
-        return new Promise((resolve, reject) => {
-            const shoperIgnoreContent = `# .shoperignore
-# Pliki i katalogi wymienione tutaj będą wykluczane z:
-# - pakowania do archiwum podczas publikacji
-# - uploadowania na serwer
-# - weryfikacji checksum
-
-# Przykłady:
-# node_modules/
-# .env
-# .env.*
-# *.log
-# temp/
-# .vscode/
-# .idea/
-`;
-            const writeStream = createWriteStream(join(themeDir, '.shoperignore'));
-            writeStream.write(shoperIgnoreContent);
-            writeStream.end();
-            writeStream.on('error', (err) => {
-                reject(err);
-            });
-            writeStream.on('finish', () => {
-                resolve();
-            });
-        });
-    }
 }

package/build/theme/features/theme/verify/verify/theme_verify_service.js

@@ -3,12 +3,12 @@ import { ThemePublishUtils } from '../../skinstore/theme_publish_utils.js';
 import { ThemePushErrorsFactory } from '../../push/theme_push_errors_factory.js';
 import { join } from '../../../../../utils/path_utils.js';
 import { v4 as uuid } from 'uuid';
-import { ThemeArchive } from '../../../../class/archive/theme_archive.js';
+import { ThemeArchiveUtils } from '../../utils/archive/theme_archive_utils.js';
+import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 import { THEME_WILDCARD_ACTION_NAME } from '../../actions/service/theme_actions_service_constants.js';
 import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
-import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
-import { ArrayUtils } from '@dreamcommerce/utilities';
+import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
 export class ThemeVerifyService {
     #loggerApi;
     constructor({ loggerApi }) {
@@ -23,13 +23,15 @@ export class ThemeVerifyService {
             throw ThemePushErrorsFactory.createErrorWhilePushingUnpublishedThemeWithSkinstoreData(credentials.shopUrl);
         try {
             this.#loggerApi.debug('Getting file records from action data.');
+            //TODO to do api?
             const filesRecords = await ThemeActionsUtils.getFilesRecordsFromActionData({
                 themeRootDir,
                 themeAction: verifyAction,
-                filesStructure
+                filesStructure,
+                themeChecksums
             });
             this.#loggerApi.debug('Filtering for modified or not created files to verify.');
-            const filesToVerify = await ArrayUtils.asyncFilter(filesRecords, async ({ path }) => (await themeChecksums.hasThemeFileBeenModified(path)) || !(await themeChecksums.hasThemeFileBeenCreated(path)));
+            const filesToVerify = filesRecords.filter(({ state }) => [FILE_STATES.modified, FILE_STATES.created].includes(state));
             this.#loggerApi.debug('Files to verify determined.', { details: { count: filesToVerify.length } });
             if (filesToVerify.length) {
                 this.#loggerApi.info(`Verifying ${filesToVerify.length} theme files.`);
@@ -46,11 +48,16 @@ export class ThemeVerifyService {
             await this._createFilesList(themeRootDir, filesToVerify);
             const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
             this.#loggerApi.info('Creating theme archive for verification.');
-            await new ThemeArchive(themeRootDir).createFullArchive({
+            await ThemeArchiveUtils.create({
                 dist: themeArchivePath,
-                actionValue: THEME_WILDCARD_ACTION_NAME,
-                actionType: THEME_ACTIONS_TYPES.push,
-                logger: this.#loggerApi
+                rootDir: themeRootDir,
+                logger: this.#loggerApi,
+                files: await ThemeActionsUtils.getFilesThatMatchesAction({
+                    actionValue: THEME_WILDCARD_ACTION_NAME,
+                    actionType: THEME_ACTIONS_TYPES.push,
+                    filesStructure,
+                    rootDir: themeRootDir
+                })
             });
             this.#loggerApi.info('Theme archive created.');
             const { isSuccess, messages } = await themeFilesUploadApi.uploadArchive({
@@ -63,11 +70,11 @@ export class ThemeVerifyService {
         }
         finally {
             this.#loggerApi.debug('Cleaning up files list.');
-            await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
+            await ThemeFilesUtils.removeAFilesListFile(themeRootDir);
         }
     }
     async _createFilesList(themeRootDir, filesRecords) {
         this.#loggerApi.debug('Creating filesList.json for the archive.');
-        await ThemeFilesStructureUtils.createAFilesListFile(themeRootDir, ThemeFilesStructureUtils.mapFilesRecordsToFilesList(filesRecords));
+        await ThemeFilesUtils.createAFilesListFile(themeRootDir, ThemeFilesUtils.mapFilesRecordsToFilesList(filesRecords));
     }
 }

package/build/theme/features/theme/watch/api/theme_watch_api.js

@@ -0,0 +1,19 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { THEME_WATCH_API_NAME } from '../theme_watch_constants.js';
+export class ThemeWatchApi extends FeatureApi {
+    moduleName = THEME_WATCH_API_NAME;
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    async watchTheme(props) {
+        return this.#service.watchTheme(props);
+    }
+    stopWatching() {
+        return this.#service.stopWatching();
+    }
+    ensureBrowserTabOpen() {
+        return this.#service.ensureBrowserTabOpen();
+    }
+}

package/build/theme/features/theme/watch/service/theme_watch_service.js

@@ -0,0 +1,167 @@
+import { AppLog } from '../../../../../cli/utilities/features/logger/logs/app_log.js';
+import chokidar from 'chokidar';
+import { APP_LOGS_TYPES } from '../../../../../cli/utilities/features/logger/logs/app_logs_constants.js';
+import { relative } from '../../../../../utils/path_utils.js';
+import { SHOP_BROWSER_TAB_ID, THEME_BATCH_DELAY_MS } from '../theme_watch_constants.js';
+import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
+export class ThemeWatchService {
+    #themePushApi;
+    #isPushing = false;
+    #pendingPush = false;
+    #browserApi;
+    #batchTimeout = null;
+    #onMessage = null;
+    #changedFiles = new Set();
+    #watcher = null;
+    #urlForWatchedTheme = null;
+    constructor({ themePushApi, browserClient }) {
+        this.#themePushApi = themePushApi;
+        this.#browserApi = new browserClient({
+            onDisconnected: () => {
+                this._onInfoMessage('Browser closed');
+            }
+        });
+    }
+    async watchTheme({ themeChecksums, executionContext, credentials, themeFilesUploadApi, filesStructure, action, openBrowser = false, onMessage }) {
+        this.#onMessage = onMessage || null;
+        const themePath = executionContext.themeRootDir;
+        this.#urlForWatchedTheme = `${credentials.shopUrl}/admin/configSkins/skin-preview/id/${executionContext.themeId}`;
+        if (openBrowser) {
+            await this.#browserApi.launch();
+            await this.#browserApi.openTab(this.#urlForWatchedTheme, SHOP_BROWSER_TAB_ID);
+        }
+        this._onInfoMessage(`Watching for changes in: ${themePath}`);
+        this.#watcher = chokidar.watch(themePath, {
+            ignored: /^(?:.*[/\\])?\..*$/,
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50
+            }
+        });
+        const handleFileChange = async (filePath) => {
+            const relativePath = relative(themePath, filePath);
+            await themeChecksums.updateCurrentChecksums();
+            const fileState = await themeChecksums.getFileState(relativePath);
+            if (fileState == FILE_STATES.unchanged)
+                return;
+            this._onInfoMessage(`Detected change in: ${relativePath}`);
+            this.#changedFiles.add(relativePath);
+            if (this.#batchTimeout)
+                this._clearQueuedBatch();
+            this.#batchTimeout = setTimeout(async () => {
+                const fileCount = this.#changedFiles.size;
+                this._onInfoMessage(`Processing batch of ${fileCount} file(s)`);
+                this.#batchTimeout = null;
+                if (this.#isPushing) {
+                    this._onInfoMessage(`Push in progress, queuing another push...`);
+                    this.#pendingPush = true;
+                    return;
+                }
+                try {
+                    await this._executePush({
+                        credentials,
+                        filesStructure,
+                        action,
+                        executionContext,
+                        themeChecksums,
+                        themeFilesUploadApi
+                    });
+                }
+                catch (err) {
+                    this.#onMessage?.(err);
+                }
+            }, THEME_BATCH_DELAY_MS);
+        };
+        this.#watcher
+            .on('add', handleFileChange)
+            .on('change', handleFileChange)
+            .on('unlink', handleFileChange)
+            .on('error', (error) => this._onErrorMessage(`Watcher error:`, error))
+            .on('ready', () => this._onInfoMessage('Initial scan complete. Ready for changes.'));
+    }
+    async ensureBrowserTabOpen() {
+        if (!this.#urlForWatchedTheme)
+            return;
+        if (!this.#browserApi.isBrowserOpen()) {
+            this._onInfoMessage(`Browser is not open, launching...`);
+            await this.#browserApi.launch();
+            await this.#browserApi.openTab(this.#urlForWatchedTheme, SHOP_BROWSER_TAB_ID);
+            this._onInfoMessage(`Browser opened with new tab`);
+            return;
+        }
+        if (!this.#browserApi.isTabOpen(SHOP_BROWSER_TAB_ID)) {
+            this._onInfoMessage(`Tab was closed, reopening...`);
+            await this.#browserApi.openTab(this.#urlForWatchedTheme, SHOP_BROWSER_TAB_ID);
+            return;
+        }
+        this._onInfoMessage(`Browser and tab already open`);
+    }
+    async stopWatching() {
+        this._onInfoMessage('Shutting down...');
+        if (this.#batchTimeout)
+            this._clearQueuedBatch();
+        await this.#watcher?.close();
+        await this.#browserApi.close();
+        this.#urlForWatchedTheme = null;
+    }
+    _clearQueuedBatch() {
+        if (this.#batchTimeout) {
+            clearTimeout(this.#batchTimeout);
+            this.#batchTimeout = null;
+        }
+    }
+    async _refreshBrowserTab() {
+        if (!SHOP_BROWSER_TAB_ID || !this.#browserApi.isTabOpen(SHOP_BROWSER_TAB_ID))
+            return;
+        try {
+            this._onInfoMessage(`Refreshing browser tab...`);
+            await this.#browserApi.refresh(SHOP_BROWSER_TAB_ID);
+            this._onInfoMessage(`Browser tab refreshed`);
+        }
+        catch (error) {
+            this._onErrorMessage(`Error refreshing browser:`, error);
+        }
+    }
+    async _executePush(params) {
+        this.#isPushing = true;
+        this.#pendingPush = false;
+        try {
+            this.#changedFiles.clear();
+            this._onInfoMessage(`Pushing theme...`);
+            await this.#themePushApi.partialPush(params);
+            this._onSuccessMessage(`Theme pushed successfully`);
+            await this._refreshBrowserTab();
+            if (this.#pendingPush) {
+                this._onInfoMessage(`Executing queued push...`);
+                this.#isPushing = false;
+                await this._executePush(params);
+            }
+        }
+        finally {
+            this.#isPushing = false;
+        }
+    }
+    _onInfoMessage(message, details) {
+        this.#onMessage?.(new AppLog({
+            level: APP_LOGS_TYPES.info,
+            message,
+            details
+        }));
+    }
+    _onErrorMessage(message, error) {
+        this.#onMessage?.(new AppLog({
+            level: APP_LOGS_TYPES.error,
+            message,
+            details: error
+        }));
+    }
+    _onSuccessMessage(message, details) {
+        this.#onMessage?.(new AppLog({
+            level: APP_LOGS_TYPES.success,
+            message,
+            details
+        }));
+    }
+}

package/build/theme/features/theme/watch/theme_watch_constants.js

@@ -0,0 +1,4 @@
+export const THEME_WATCH_FEATURE_NAME = 'ThemeWatch';
+export const THEME_WATCH_API_NAME = 'ThemeWatchApi';
+export const THEME_BATCH_DELAY_MS = 750;
+export const SHOP_BROWSER_TAB_ID = 'shop-page';

package/build/theme/features/theme/watch/theme_watch_initializer.js

@@ -0,0 +1,22 @@
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { THEME_WATCH_FEATURE_NAME } from './theme_watch_constants.js';
+import { ThemeWatchService } from './service/theme_watch_service.js';
+import { THEME_PUSH_API_NAME } from '../push/theme_push_constants.js';
+import { ThemeWatchApi } from './api/theme_watch_api.js';
+import { Browser } from '../../../class/browser/browser.js';
+//TODO to pownna byc inicjalizacja w komponencie reaktowym/komendzie watch.tsx
+export class ThemeWatchInitializer extends SyncFeatureInitializer {
+    static featureName = THEME_WATCH_FEATURE_NAME;
+    init() {
+        const themePushApi = this.getApiSync(THEME_PUSH_API_NAME);
+        const service = new ThemeWatchService({ themePushApi, browserClient: Browser });
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemeWatchApi(service)
+                }
+            ]
+        };
+    }
+}

package/build/theme/index.js

@@ -15,6 +15,8 @@ import { ThemePushInitializer } from './features/theme/push/theme_push_initializ
 import { ThemeVerifyInitializer } from './features/theme/verify/theme_verify_initializer.js';
 import { ThemeDeleteInitializer } from './features/theme/delete/theme_delete_initalizer.js';
 import { ThemeActionsInitializer } from './features/theme/actions/theme_actions_initializer.js';
+import { ThemeWatchCommand } from './commands/watch/theme_watch_command.js';
+import { ThemeWatchInitializer } from './features/theme/watch/theme_watch_initializer.js';
 export const COMMANDS = {
     [THEME_COMMANDS_NAME.list]: ThemeListCommand,
     [THEME_COMMANDS_NAME.pull]: ThemePullCommand,
@@ -23,14 +25,16 @@ export const COMMANDS = {
     [THEME_COMMANDS_NAME.verify]: ThemeVerifyCommand,
     [THEME_COMMANDS_NAME.info]: ThemeInfoCommand,
     [THEME_COMMANDS_NAME.delete]: ThemeDeleteCommand,
-    [THEME_COMMANDS_NAME.publish]: ThemePublishCommand
+    [THEME_COMMANDS_NAME.publish]: ThemePublishCommand,
+    [THEME_COMMANDS_NAME.watch]: ThemeWatchCommand
 };
 export const COMMAND_TO_FEATURES_MAP = {
     [THEME_COMMANDS_NAME.pull]: [ThemeMergeInitializer, ThemeFetchInitializer],
     [THEME_COMMANDS_NAME.init]: ThemeInitInitializer,
     [THEME_COMMANDS_NAME.push]: [ThemeFetchInitializer, ThemePushInitializer],
     [THEME_COMMANDS_NAME.verify]: ThemeVerifyInitializer,
-    [THEME_COMMANDS_NAME.delete]: ThemeDeleteInitializer
+    [THEME_COMMANDS_NAME.delete]: ThemeDeleteInitializer,
+    [THEME_COMMANDS_NAME.watch]: [ThemeFetchInitializer, ThemePushInitializer, ThemeWatchInitializer]
 };
 export const getThemeInitializersForCommand = (commandName) => {
     if (!commandName)

package/build/theme/utils/directory_validator/directory_validator_utils.js

@@ -5,7 +5,7 @@ import { computeFileChecksum } from '../../../utils/checksums/checksums_utils.js
 import { DEFAULT_PERMISSION_FOR_ALL_FILES_KEY, DEFAULT_PERMISSION_FOR_DIRECTORY_KEY, FILES_MODIFICATION_TYPES, PERMISSION_KEY } from './directory_validator_constants.js';
 import { CHECKSUM_KEY } from '../../../utils/checksums/checksums_utils_constants.js';
 import _ from 'lodash';
-export const validateDirectory = async ({ rootDirectory, permissions, checksums, ignoreInstance }) => {
+export const validateDirectory = async ({ rootDirectory, permissions, checksums }) => {
     const unpermittedActions = [];
     await _checkPermissions({
         permissions,
@@ -14,15 +14,14 @@ export const validateDirectory = async ({ rootDirectory, permissions, checksums,
         parts: [],
         checksumsPart: checksums,
         rootDirectory,
-        unpermittedActions,
-        ignoreInstance
+        unpermittedActions
     });
     return {
         isValid: !unpermittedActions.length,
         unpermittedActions
     };
 };
-const _checkPermissions = async ({ permissionPart, permissionParts, parts = [], checksumsPart, rootDirectory, unpermittedActions, permissions, ignoreInstance }) => {
+const _checkPermissions = async ({ permissionPart, permissionParts, parts = [], checksumsPart, rootDirectory, unpermittedActions, permissions }) => {
     if (!permissionPart)
         return;
     //TODO required files in a custom module directory
@@ -41,11 +40,6 @@ const _checkPermissions = async ({ permissionPart, permissionParts, parts = [],
         filesInsideCurrentDirectoryObject[path] = true;
     });
     for (const file of files) {
-        const relativePath = join(parentPath, file);
-        // Skip files that are in .shoperignore
-        if (ignoreInstance && ignoreInstance.ignores(relativePath)) {
-            continue;
-        }
         const { permission, permissionKey } = _getPermission({
             path: file,
             fullPath: join(fullPath, file),
@@ -71,8 +65,7 @@ const _checkPermissions = async ({ permissionPart, permissionParts, parts = [],
                 checksumsPart: checksumsPart?.[file] ?? {},
                 rootDirectory,
                 unpermittedActions,
-                permissions,
-                ignoreInstance
+                permissions
             });
         }
     }

package/build/ui/command_input/command_input.js

@@ -0,0 +1,25 @@
+import { Box } from '../box.js';
+import { Text } from '../text.js';
+import React, { useState } from 'react';
+import TextInput from 'ink-text-input';
+import { COMMAND_PREFIX } from '../../theme/commands/watch/theme_watch_constants.js';
+export const CommandInput = ({ onSubmit, commands = [] }) => {
+    const [query, setQuery] = useState('');
+    const showSuggestions = query.startsWith(COMMAND_PREFIX);
+    const searchTerm = query.substring(1);
+    const filteredCommands = commands.filter((cmd) => cmd.key.startsWith(searchTerm));
+    const handleSubmit = (value) => {
+        onSubmit(value);
+        setQuery('');
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { borderStyle: "round", borderColor: "blue", paddingX: 1, flexDirection: "row" },
+            React.createElement(Text, { color: "blue" }, '> '),
+            React.createElement(TextInput, { value: query, onChange: setQuery, onSubmit: handleSubmit, placeholder: `Type ${COMMAND_PREFIX} to see commands...` })),
+        showSuggestions ? (React.createElement(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2 },
+            filteredCommands.map((cmd) => (React.createElement(Box, { key: cmd.key },
+                React.createElement(Box, { width: 15 },
+                    React.createElement(Text, { color: "cyan", bold: true }, cmd.key)),
+                React.createElement(Text, { color: "gray" }, cmd.description)))),
+            filteredCommands.length === 0 && React.createElement(Text, { color: "red" }, "No matching commands found"))) : null));
+};

package/build/ui/logs/log_entry.js

@@ -0,0 +1,12 @@
+export class LogEntry {
+    id;
+    type;
+    content;
+    timestamp;
+    constructor({ id, type, content, timestamp }) {
+        this.id = id;
+        this.type = type;
+        this.content = content;
+        this.timestamp = timestamp;
+    }
+}

package/build/ui/logs/logs_constants.js

@@ -0,0 +1,20 @@
+import { CSS_TEXT_COLORS } from '../color_constants.js';
+export const LOG_TYPES = {
+    info: 'info',
+    success: 'success',
+    error: 'error',
+    warning: 'warning',
+    custom: 'custom'
+};
+export const MAP_LOG_TYPE_TO_TEXT_COLOR = {
+    [LOG_TYPES.info]: CSS_TEXT_COLORS.info,
+    [LOG_TYPES.success]: CSS_TEXT_COLORS.success,
+    [LOG_TYPES.error]: CSS_TEXT_COLORS.danger,
+    [LOG_TYPES.warning]: CSS_TEXT_COLORS.warning
+};
+export const MAP_LOG_TYPE_TO_LABEL = {
+    [LOG_TYPES.info]: 'INFO',
+    [LOG_TYPES.success]: 'SUCCESS',
+    [LOG_TYPES.error]: 'ERROR',
+    [LOG_TYPES.warning]: 'WARNING'
+};

package/build/ui/logs/logs_list.js

@@ -0,0 +1,18 @@
+import { Box } from '../box.js';
+import { Text } from '../text.js';
+import React from 'react';
+import { LOG_TYPES, MAP_LOG_TYPE_TO_LABEL, MAP_LOG_TYPE_TO_TEXT_COLOR } from './logs_constants.js';
+export const LogsList = ({ logs }) => {
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1, width: "100%" }, logs.map((log) => {
+        if (log.type === LOG_TYPES.custom)
+            return React.createElement(Box, { key: log.id }, log.content);
+        const logLabel = MAP_LOG_TYPE_TO_LABEL[log.type];
+        const logColor = MAP_LOG_TYPE_TO_TEXT_COLOR[log.type];
+        return typeof log.content === 'string' ? (React.createElement(Text, { key: log.id },
+            React.createElement(Text, { color: logColor },
+                "[",
+                logLabel,
+                "] "),
+            log.content)) : (log.content);
+    })));
+};

package/build/ui/logs/use_logs.js

@@ -0,0 +1,23 @@
+import { useState } from 'react';
+import { LOG_TYPES } from './logs_constants.js';
+import { LogEntry } from './log_entry.js';
+import { v4 as uuid } from 'uuid';
+export const useLogs = (maxLogs) => {
+    const [logs, setLogs] = useState([]);
+    const addLog = (content, type = LOG_TYPES.info) => {
+        setLogs((prev) => {
+            const newLogs = [
+                ...prev,
+                new LogEntry({
+                    id: uuid(),
+                    type,
+                    content,
+                    timestamp: Date.now()
+                })
+            ];
+            return newLogs.slice(-maxLogs);
+        });
+    };
+    const clearLogs = () => setLogs([]);
+    return { logs, addLog, clearLogs };
+};