@shoper/cli 0.1.0-9 → 0.2.0

package/build/cli/features/execution_context/execution_context_service.js

@@ -1,10 +1,10 @@
 import process from 'node:process';
 import { EXECUTION_CONTEXTS } from './execution_context_constants.js';
-import { ThemeDirectoryUtils } from '../../../theme/features/theme/directory/theme_directory_utils.js';
+import { ThemeMetaDataUtils } from '../../../theme/features/theme/utils/meta_data/theme_meta_data_utils.js';
 export class ExecutionContextService {
     #executionContext;
     async _obtainExecutionContext() {
-        if (await ThemeDirectoryUtils.closestThemeRootDirectory(process.cwd())) {
+        if (await ThemeMetaDataUtils.closestThemeRootDirectory(process.cwd())) {
             return await this.getThemeExecutionContext();
         }
         return await this._getGlobalExecutionContext();
@@ -20,14 +20,14 @@ export class ExecutionContextService {
         return this.#executionContext;
     }
     async getThemeExecutionContext() {
-        const themeRoot = await ThemeDirectoryUtils.closestThemeRootDirectory(process.cwd());
+        const themeRoot = await ThemeMetaDataUtils.closestThemeRootDirectory(process.cwd());
         //TODO errors
         if (!themeRoot)
             throw 'Theme root directory not found';
-        const themeDirectoryMetadata = await ThemeDirectoryUtils.getThemeDirectoryMetadata(themeRoot);
+        const themeMetaData = await ThemeMetaDataUtils.getThemeMetadata(themeRoot);
         return {
             type: EXECUTION_CONTEXTS.theme,
-            themeId: themeDirectoryMetadata.themeId,
+            themeId: themeMetaData.themeId,
             executionDir: process.cwd(),
             themeRootDir: themeRoot
         };

package/build/cli/features/http_requester/http_requester_initializer.js

@@ -1,6 +1,6 @@
 import { CACHE_TYPES, CacheService, DEFAULT_REQUESTER_CACHE_NAMESPACE, FEATURE_CORES_TYPES, HTTP_REQUESTER_FEATURE_NAME, HTTPRequesterApi, HTTPRequesterBalancer, REQUEST_SOURCE, Requester, RequesterCacheServiceKeySerializer, SANITIZER_API_NAME, StrategiesContainer, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { HttpClient } from './http_client.js';
-import { CacheFactory } from '../caches/cache_factory.js';
+import { CacheFactory } from '../../class/caches/cache_factory.js';
 export class HTTPRequesterInitializer extends SyncFeatureInitializer {
     static featureName = HTTP_REQUESTER_FEATURE_NAME;
     init() {

package/build/cli/hooks/authorization/ensure_authorization_hook.js

@@ -1,11 +1,11 @@
-import { COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION } from './ensure_authorization_hook_constants.js';
+import { COMMANDS_THAT_REQUIRE_AUTHORIZATION } from './ensure_authorization_hook_constants.js';
 import { useApi } from '../ensure_cli_initialized_hook.js';
 import { CLI_AUTH_API_NAME } from '../../auth/cli_auth_constants.js';
 import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
 import { promptForToken } from '../../commands/utils/prompt_for_token_utils.js';
 import { CliAuthUtils } from '../../auth/cli_auth_utils.js';
 const ensureAuthorizationHook = async ({ Command }) => {
-    if (COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION.includes(Command.id))
+    if (!COMMANDS_THAT_REQUIRE_AUTHORIZATION.includes(Command.id))
         return;
     const cliAuthApi = useApi(CLI_AUTH_API_NAME);
     const cliAuthTokensApi = useApi(CLI_AUTH_TOKENS_API_NAME);

package/build/cli/hooks/authorization/ensure_authorization_hook_constants.js

@@ -1,9 +1,9 @@
-import { CLI_COMMANDS_NAMES } from '../../commands/commands_constants.js';
-export const COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION = [
-    CLI_COMMANDS_NAMES.update,
-    CLI_COMMANDS_NAMES.update,
-    CLI_COMMANDS_NAMES.authAddToken,
-    CLI_COMMANDS_NAMES.authRemoveToken,
-    CLI_COMMANDS_NAMES.authListTokens,
-    CLI_COMMANDS_NAMES.switchToken
+import { THEME_COMMANDS_NAME } from '../../../theme/commands/theme_commands_constants.js';
+export const COMMANDS_THAT_REQUIRE_AUTHORIZATION = [
+    THEME_COMMANDS_NAME.push,
+    THEME_COMMANDS_NAME.pull,
+    THEME_COMMANDS_NAME.list,
+    THEME_COMMANDS_NAME.init,
+    THEME_COMMANDS_NAME.showChanges,
+    THEME_COMMANDS_NAME.verify
 ];

package/build/index.js

@@ -7,6 +7,7 @@ import { CliAuthListTokensCommand } from './cli/commands/auth/cli_auth_list_toke
 import { CliAuthAddTokenCommand } from './cli/commands/auth/cli_auth_add_token_command.js';
 import { CliAuthRemoveTokenCommand } from './cli/commands/auth/cli_auth_remove_token_command.js';
 import { CliAuthSwitchTokenCommand } from './cli/commands/auth/cli_auth_switch_token_command.js';
+import { CliUIDumpCommand } from './cli/commands/cli_ui_dump_command.js';
 //TODO
 //@ts-ignore
 if (typeof global.crypto !== 'object') {
@@ -42,27 +43,44 @@ export const COMMANDS = {
     [CLI_COMMANDS_NAMES.authAddToken]: CliAuthAddTokenCommand,
     [CLI_COMMANDS_NAMES.authRemoveToken]: CliAuthRemoveTokenCommand,
     [CLI_COMMANDS_NAMES.switchToken]: CliAuthSwitchTokenCommand,
+    [CLI_COMMANDS_NAMES.uiDump]: CliUIDumpCommand,
     ...THEME_COMMANDS
 };
 export { runCLI } from './cli/index.js';
 /**
- * TODO:
- * testy verify
- *  - usuniecie po koleji .shoper, macros, modules, settings, styles...
- *  testy theme show-changes
- *    - macro
- *      - dodawanie, zmienianie i usuwanie makr
- *  testy theme verify
- *    - makro
- *     - dodawanie, zmienianie i usuwanie makr
- * testy pull push
- * - nie skinstore
- *      - push nowego modułu, podmieni sie folder i checksumy przywróćenie foledu bez checksum i push error z permissions
- *      - dodawanie, modzenie i usuwanie customowych makr
- *      - modzenie makr
- *      - dodawanie i usuwanie customowych modułów
- *      - podmiana thumbnail
- * - skinstore
- *      - modzenie danych settingsów skinstore
- *      - dodawanie, usuwanie, podmienianie obrazków
+ * Przetestowane na win
+ * oglne
+ * moduly:
+ *   - stworzony w admince
+ *      - pull w cli - v
+ *      - updejt modulu w adminc i pull w cli - v
+ *      - zmiana nazwy katalogu w cli, modzenie w admince i pull - v
+ *      - kopiowanie stworzonego modulu w admince i push (usuniety id i code) - v
+ *      - zminaa w cli i push - v
+ *   - tworzenie modulu w cli, min plikow i push
+ *      - aktualizowanie js/twig/settings/schema
+ *      - zmiana w adminc i pull
+ *   - usuwanie modulu z cli - v
+ *   - usuwanie modulu z adminki - v
+ *   - dodanie niedozwolonego pliku do folderu modulu
+ *   - dodanie niedozwolonego pliku do folderu modules/
+ *   - translacje - v
+ * macro:
+ *   - dodawanie pliku do macros - v
+ *   - usuniecie macro - v
+ *   - modzneie makro - v
+ *   - dodawanie customowego macro - v
+ *   - push customowego macro - v
+ *   - modzenie w admince i pull - v
+ * settingsy:
+ *   - uzupelniania schemy w admince, pull w cli
+ *   - uzupelnianie wartosci a admince i pull
+ *   - modzenie w cli
+ *   - usuniecie pliku w cli
+ * styles:
+ *   - modzenie stylu w src - niedozwolone - v
+ *   - modzenie custom - v
+ *   - usuniecie custom - v
+ *   - modzenie schema i settings - v
+ * dodanie czegos w .shoper
  */

package/build/theme/class/checksums/theme_checksums.js

@@ -0,0 +1,174 @@
+import { copyFile, fileExists, readJSONFile, readJSONFileSync, removeFile } from '../../../utils/fs/fs_utils.js';
+import { ThemeChecksumsUtils } from './theme_checksums_utils.js';
+import { isWindowsOs } from '../../../utils/platform_utils.js';
+import { join, mapKeysPathsToWindowPlatform, toCurrentPlatformPath } from '../../../utils/path_utils.js';
+import { createWriteStream } from 'node:fs';
+import { JSON_FILE_INDENT } from '../../../cli/cli_constants.js';
+import { ThemeChecksumsErrorFactory } from './theme_checksums_error_factory.js';
+import { computeChecksumsFromFilesStructure, computeDirectoriesChecksums, computeFileChecksum } from '../../../utils/checksums/checksums_utils.js';
+import { normalize } from 'node:path';
+import { ThemePushUtils } from '../../../theme/features/theme/push/theme_push_utils.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../../theme/constants/directory_contstants.js';
+import { THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME, THEME_CURRENT_CHECKSUMS_FILE_NAME, THEME_INITIAL_CHECKSUMS_FILE_NAME } from '../../../theme/features/theme/theme_constants.js';
+export class ThemeChecksums {
+    #themeDir;
+    #currentChecksumsFilePath;
+    #currentChecksumsVerificationFilePath;
+    #initialChecksumsFilePath;
+    #initialChecksumsVerificationFilePath;
+    #initialChecksums;
+    #currentChecksums;
+    constructor(themeDir) {
+        this.#themeDir = themeDir;
+        this.#currentChecksumsFilePath = ThemeChecksumsUtils.getCurrentThemeChecksumsFilePath(themeDir);
+        this.#currentChecksumsVerificationFilePath = ThemeChecksumsUtils.getCurrentThemeChecksumsVerificationFilePath(themeDir);
+        this.#initialChecksumsFilePath = ThemeChecksumsUtils.getInitialThemeChecksumsFilePath(themeDir);
+        this.#initialChecksumsVerificationFilePath = ThemeChecksumsUtils.getInitialThemeChecksumsVerificationFilePath(themeDir);
+    }
+    async getInitialChecksums() {
+        if (this.#initialChecksums)
+            return this.#initialChecksums;
+        this.#initialChecksums = await this._getChecksums(this.#initialChecksumsFilePath);
+        return this.#initialChecksums;
+    }
+    getInitialChecksumsSync() {
+        if (this.#initialChecksums)
+            return this.#initialChecksums;
+        this.#initialChecksums = this._getChecksumsSync(this.#initialChecksumsFilePath);
+        return this.#initialChecksums;
+    }
+    async getCurrentChecksums() {
+        if (this.#currentChecksums)
+            return this.#currentChecksums;
+        this.#currentChecksums = await this._getChecksums(this.#currentChecksumsFilePath);
+        return this.#currentChecksums;
+    }
+    getCurrentChecksumsSync() {
+        if (this.#currentChecksums)
+            return this.#currentChecksums;
+        this.#currentChecksums = this._getChecksumsSync(this.#currentChecksumsFilePath);
+        return this.#currentChecksums;
+    }
+    async getCurrentChecksumFromPath(path) {
+        const checksums = await this.getCurrentChecksums();
+        return checksums[toCurrentPlatformPath(path)];
+    }
+    getCurrentChecksumFromPathSync(path) {
+        const checksums = this.getCurrentChecksumsSync();
+        return checksums[toCurrentPlatformPath(path)];
+    }
+    async getInitialChecksumFromPath(path) {
+        const checksums = await this.getInitialChecksums();
+        return checksums[toCurrentPlatformPath(path)];
+    }
+    getInitialChecksumFromPathSync(path) {
+        const checksums = this.getInitialChecksumsSync();
+        return checksums[toCurrentPlatformPath(path)];
+    }
+    async hasThemeBeenModified() {
+        const initialChecksums = await this._getInitialChecksumsVerification();
+        const currentChecksums = await this._getCurrentChecksumsVerification();
+        return !!initialChecksums && !!currentChecksums && initialChecksums !== currentChecksums;
+    }
+    async hasThemeFileBeenCreated(path) {
+        const initialChecksum = await this.getInitialChecksumFromPath(path);
+        return !initialChecksum && (await fileExists(join(this.#themeDir, path)));
+    }
+    async hasThemeFileBeenModified(path) {
+        const currentChecksum = await this.getCurrentChecksumFromPath(path);
+        const initialChecksum = await this.getInitialChecksumFromPath(path);
+        return !!currentChecksum && !!initialChecksum && currentChecksum !== initialChecksum;
+    }
+    async verify() {
+        const initialChecksumFilePath = this.#initialChecksumsFilePath;
+        const initialChecksumVerifyFilePath = this.#initialChecksumsVerificationFilePath;
+        const initialChecksum = await computeFileChecksum(initialChecksumFilePath);
+        const initialChecksumVerify = await readJSONFile(initialChecksumVerifyFilePath);
+        return initialChecksum === initialChecksumVerify;
+    }
+    async updateAllChecksums() {
+        const checksums = await this.computeThemeChecksums();
+        return new Promise((resolve, reject) => {
+            const currentChecksumFilePath = this.#currentChecksumsFilePath;
+            const initialChecksumFilePath = this.#initialChecksumsFilePath;
+            const checksumStream = createWriteStream(initialChecksumFilePath);
+            checksumStream.write(JSON.stringify(checksums, null, JSON_FILE_INDENT));
+            checksumStream.end();
+            checksumStream
+                .on('finish', async () => {
+                const initialChecksumVerifyFilePath = this.#initialChecksumsVerificationFilePath;
+                const currentChecksumVerifyFilePath = this.#currentChecksumsVerificationFilePath;
+                await this._createThemeChecksumVerifyFile(initialChecksumFilePath, initialChecksumVerifyFilePath);
+                await copyFile(initialChecksumFilePath, currentChecksumFilePath);
+                await copyFile(initialChecksumVerifyFilePath, currentChecksumVerifyFilePath);
+                resolve();
+            })
+                .on('error', async (err) => {
+                await removeFile(initialChecksumFilePath, { force: true });
+                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack));
+            });
+        });
+    }
+    async updateCurrentChecksums() {
+        const checksums = await this.computeThemeChecksums();
+        return new Promise((resolve, reject) => {
+            const currentChecksumFilePath = this.#currentChecksumsFilePath;
+            const checksumStream = createWriteStream(currentChecksumFilePath);
+            checksumStream.write(JSON.stringify(checksums, null, JSON_FILE_INDENT));
+            checksumStream.end();
+            checksumStream
+                .on('finish', async () => {
+                const currentChecksumVerifyFilePath = this.#currentChecksumsVerificationFilePath;
+                await this._createThemeChecksumVerifyFile(currentChecksumFilePath, currentChecksumVerifyFilePath);
+                resolve();
+            })
+                .on('error', async (err) => {
+                await removeFile(currentChecksumFilePath, { force: true });
+                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack));
+            });
+        });
+    }
+    async computeThemeChecksums() {
+        const filesToIgnoreInChecksums = [
+            join(SHOPER_THEME_METADATA_DIR, THEME_CURRENT_CHECKSUMS_FILE_NAME),
+            join(SHOPER_THEME_METADATA_DIR, THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME),
+            join(SHOPER_THEME_METADATA_DIR, THEME_INITIAL_CHECKSUMS_FILE_NAME),
+            join(SHOPER_THEME_METADATA_DIR, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME)
+        ];
+        const filesToComputeChecksums = (await ThemePushUtils.getAllFilesThatAreSendToRemote(this.#themeDir))
+            .filter((path) => !filesToIgnoreInChecksums.some((ignorePath) => normalize(path) === ignorePath))
+            .map((relativePath) => join(this.#themeDir, relativePath));
+        const { filesChecksumsInDirectories, filesChecksums } = await computeChecksumsFromFilesStructure(filesToComputeChecksums, this.#themeDir);
+        const directoriesChecksums = computeDirectoriesChecksums(filesChecksumsInDirectories);
+        return { ...filesChecksums, ...directoriesChecksums };
+    }
+    async _getInitialChecksumsVerification() {
+        return await readJSONFile(this.#initialChecksumsVerificationFilePath);
+    }
+    async _getCurrentChecksumsVerification() {
+        return await readJSONFile(this.#currentChecksumsVerificationFilePath);
+    }
+    async _getChecksums(path) {
+        const checksums = await readJSONFile(path);
+        if (!isWindowsOs())
+            return checksums;
+        return mapKeysPathsToWindowPlatform(checksums);
+    }
+    _getChecksumsSync(path) {
+        const checksums = readJSONFileSync(path);
+        if (!isWindowsOs())
+            return checksums;
+        return mapKeysPathsToWindowPlatform(checksums);
+    }
+    async _createThemeChecksumVerifyFile(checksumFilePath, checksumVerifyFullPath) {
+        const checksumVerifyStream = createWriteStream(checksumVerifyFullPath);
+        const checksumVerify = await computeFileChecksum(checksumFilePath);
+        checksumVerifyStream
+            .on('error', async (err) => {
+            await removeFile(checksumFilePath, { force: true });
+            throw ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack);
+        })
+            .write(JSON.stringify(checksumVerify));
+        checksumVerifyStream.end();
+    }
+}

package/build/theme/{features/theme/utils → class}/checksums/theme_checksums_error_factory.js

@@ -1,4 +1,4 @@
-import { AppError } from '../../../../../cli/class/errors/app_error/app_error.js';
+import { AppError } from '../../../cli/class/errors/app/app_error.js';
 export class ThemeChecksumsErrorFactory {
     static createThemeChecksumError(stack) {
         return new AppError({

package/build/theme/class/checksums/theme_checksums_utils.js

@@ -0,0 +1,17 @@
+import { join } from '../../../utils/path_utils.js';
+import { THEME_CURRENT_CHECKSUMS_FILE_NAME, THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME, THEME_INITIAL_CHECKSUMS_FILE_NAME, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME } from '../../features/theme/theme_constants.js';
+import { HiddenDirectoryUtils } from '../../features/theme/utils/hidden_directory/hidden_directory_utils.js';
+export class ThemeChecksumsUtils {
+    static getCurrentThemeChecksumsFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_CURRENT_CHECKSUMS_FILE_NAME);
+    }
+    static getInitialThemeChecksumsFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_INITIAL_CHECKSUMS_FILE_NAME);
+    }
+    static getCurrentThemeChecksumsVerificationFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME);
+    }
+    static getInitialThemeChecksumsVerificationFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME);
+    }
+}

package/build/theme/class/fetch_resources/fetch_resources.js

@@ -58,6 +58,7 @@ export class FetchResources {
                 });
             }));
         }
+        return;
     }
     async _getResourcesFileContent(resourcePath) {
         return mapResourcesToTree(await readJSONFile(resourcePath));

package/build/theme/class/fetch_resources/fetch_resources_errors_factory.js

@@ -1,4 +1,4 @@
-import { AppError } from '../../../cli/class/errors/app_error/app_error.js';
+import { AppError } from '../../../cli/class/errors/app/app_error.js';
 export class FetchResourcesErrorsFactory {
     static createErrorFetchingResource(shopUrl, messages) {
         return new AppError({

package/build/theme/class/fetch_resources/fetch_resources_utils.js

@@ -1,7 +1,7 @@
 import { join } from '../../../utils/path_utils.js';
 import { RESOURCES_FILE_NAME } from './fetch_resources_constants.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.js';
-import { fileExists, readJSONFile } from '../../../utils/fs/fs_utils.js';
+import { fileExists, readJSONFile, removeFiles } from '../../../utils/fs/fs_utils.js';
 export const isResourceObject = (resource) => {
     return typeof resource === 'object' && resource !== null && 'url' in resource && typeof resource.url === 'string';
 };
@@ -15,6 +15,9 @@ export const getResources = async (root) => {
     }
     return await readJSONFile(resourcesPath);
 };
+export const removeOldResources = async (rootDir, resources) => {
+    await removeFiles(Object.keys(resources).map((path) => join(rootDir, path)));
+};
 export const mapResourcesToTree = (resources, separator = '/') => {
     const tree = {};
     Object.entries(resources).forEach(([path, value]) => {

package/build/theme/commands/delete/theme_delete_command.js

@@ -0,0 +1,111 @@
+import { Args } from '@oclif/core';
+import { BaseThemeCommand } from '../../class/base_theme_command.js';
+import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
+import { THEME_ACTION_NOT_FOUND_ERROR_CODE, THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../../features/theme/actions/theme_actions_constants.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
+import { renderOnce } from '../../../ui/ui_utils.js';
+import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
+import React from 'react';
+import { THEME_DELETE_API_NAME } from '../../features/theme/delete/theme_delete_constants.js';
+import { UnpermittedCommandError } from '../ui/unpermitted_command_error.js';
+import { Error } from '../../../ui/message_box/error.js';
+import { Text } from '../../../ui/text.js';
+import { Info } from '../../../ui/message_box/info.js';
+import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
+import { Box } from '../../../ui/box.js';
+import { ThemeDeletedSuccessfully } from './ui/theme_deleted_successfully.js';
+import { ThemeDeletionWarning } from './ui/theme_deletion_warning.js';
+import { promptConfirmation } from '../../../ui/prompts/prompt_confirmation.js';
+export class ThemeDeleteCommand extends BaseThemeCommand {
+    static summary = 'Permanently deletes the specified theme from your store.';
+    static description = 'This action cannot be undone, so make sure you really want to remove this theme.\n\nYou can run this command from a specific theme directory (ID not needed) or outside any theme directory (theme ID required).';
+    static examples = [
+        {
+            description: 'This will delete the theme with ID 123 permanently from your store. Make sure you have a backup if needed.',
+            command: '<%= config.bin %> <%= command.id %> 123'
+        }
+    ];
+    static hidden = true;
+    static args = {
+        id: Args.string({
+            description: 'Theme id',
+            name: 'id',
+            required: false,
+            type: 'string'
+        })
+    };
+    async run() {
+        const data = await this.parse(ThemeDeleteCommand);
+        const { args } = data;
+        const themeId = args.id;
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials) {
+            renderOnce(React.createElement(MissingCredentialsError, null));
+            return;
+        }
+        const executionContext = await executionContextApi.getExecutionContext();
+        try {
+            let _themeId = themeId;
+            if (executionContext.type !== EXECUTION_CONTEXTS.theme && !_themeId) {
+                renderOnce(React.createElement(MissingThemeIdError, null,
+                    React.createElement(Box, { flexDirection: "column", gap: 1 },
+                        React.createElement(Text, null, "Usage: shoper theme delete [ID]"),
+                        React.createElement(Text, null, "Please run this command inside a theme directory or provide a theme ID."))));
+                return;
+            }
+            if (executionContext.type === EXECUTION_CONTEXTS.theme)
+                _themeId = _themeId ?? executionContext.themeId;
+            if (!_themeId) {
+                renderOnce(React.createElement(MissingThemeIdError, null));
+                return;
+            }
+            const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+            const deleteAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.delete,
+                themeId: _themeId,
+                credentials
+            });
+            if (!deleteAction) {
+                renderOnce(React.createElement(UnpermittedCommandError, { themeId: _themeId, commandName: "delete" }));
+                return;
+            }
+            renderOnce(React.createElement(ThemeDeletionWarning, { themeId: _themeId }));
+            const { proceed } = await promptConfirmation('Proceed?');
+            if (!proceed) {
+                renderOnce(React.createElement(Info, { header: "Theme deletion was cancelled." }));
+                return;
+            }
+            const themeDeleteApi = this.getApi(THEME_DELETE_API_NAME);
+            const resp = await themeDeleteApi.deleteTheme({
+                actionData: deleteAction.data,
+                credentials
+            });
+            themeActionsApi.removeThemeActions({
+                themeId: _themeId,
+                credentials
+            });
+            if (!resp?.isSuccess)
+                return;
+            renderOnce(React.createElement(ThemeDeletedSuccessfully, null));
+            return;
+        }
+        catch (err) {
+            this._handleError(err, themeId);
+            return;
+        }
+    }
+    _handleError(err, themeId) {
+        if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE && themeId) {
+            renderOnce(React.createElement(UnpermittedCommandError, { themeId: themeId, commandName: "delete" }));
+            return;
+        }
+        if (err?.message) {
+            renderOnce(React.createElement(Error, null,
+                React.createElement(Text, null, err.message)));
+            return;
+        }
+        this.error(String(err));
+    }
+}

package/build/theme/commands/delete/ui/theme_deleted_successfully.js

@@ -0,0 +1,15 @@
+import React from 'react';
+import { Text } from '../../../../ui/text.js';
+import { List } from '../../../../ui/list/list.js';
+import { Tip } from '../../../../ui/tip.js';
+import { Success } from '../../../../ui/message_box/success.js';
+export const ThemeDeletedSuccessfully = () => {
+    return (React.createElement(Success, { header: "Success: Theme was deleted from the store." },
+        React.createElement(Text, null, "The theme is no longer available in your store panel, but its files remain locally."),
+        React.createElement(Tip, null, "If you want to reuse this theme:"),
+        React.createElement(List, { items: [
+                'create a new theme using shoper theme init [id]',
+                'copy the local files into the new theme folder',
+                'and push it using shoper theme push'
+            ] })));
+};

package/build/theme/commands/delete/ui/theme_deletion_warning.js

@@ -0,0 +1,10 @@
+import { Warning } from '../../../../ui/message_box/warning.js';
+import { Text } from '../../../../ui/text.js';
+import React from 'react';
+export const ThemeDeletionWarning = ({ themeId }) => {
+    return (React.createElement(Warning, { header: `Warning: This will permanently delete the theme (ID: ${themeId}) from your store and cannot be undone.` },
+        React.createElement(Text, null,
+            "Your local files ",
+            React.createElement(Text, { bold: true }, "will not be removed"),
+            ". You\u2019ll still be able to access and modify them.")));
+};

package/build/theme/commands/info/theme_info_command.js

@@ -0,0 +1,94 @@
+import { BaseThemeCommand } from '../../class/base_theme_command.js';
+import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
+import { renderOnce } from '../../../ui/ui_utils.js';
+import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
+import React from 'react';
+import { THEMES_LIST_API_NAME } from '../../features/themes/list/themes_list_constants.js';
+import { Args } from '@oclif/core';
+import { ThemeMetaDataUtils } from '../../features/theme/utils/meta_data/theme_meta_data_utils.js';
+import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
+import { Text } from '../../../ui/text.js';
+import { THEME_WORK_URL_MISMATCH_ERROR } from '../../features/theme/utils/meta_data/theme_meta_data_constants.js';
+import { Error } from '../../../ui/message_box/error.js';
+import { ThemeWorkUrlMismatch } from '../ui/theme_work_url_mismatch.js';
+import { Table } from '../../../ui/table/table.js';
+import { ThemeInfoCommandUtils } from './theme_info_command_utils.js';
+import { InvalidThemeIdError } from '../ui/invalid_theme_id.js';
+import { Box } from '../../../ui/box.js';
+export class ThemeInfoCommand extends BaseThemeCommand {
+    static summary = 'View details about the current theme.';
+    static description = 'Displays key information about the theme you’re working on — including its ID, name, description (if provided), and status.\n\nYou can run this command from a specific theme directory (ID not needed) or outside any theme directory (theme ID required).';
+    static examples = [
+        {
+            description: 'The command will display the theme ID, name, description, and status.',
+            command: '<%= config.bin %> <%= command.id %> 2'
+        }
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Theme id',
+            name: 'id',
+            type: 'string'
+        })
+    };
+    async run() {
+        const data = await this.parse(ThemeInfoCommand);
+        const { args } = data;
+        const themeId = args.id;
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const themesListApi = this.getApi(THEMES_LIST_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials) {
+            renderOnce(React.createElement(MissingCredentialsError, null));
+            return;
+        }
+        const executionContext = await executionContextApi.getExecutionContext();
+        try {
+            let _themeId = themeId;
+            if (executionContext.type !== EXECUTION_CONTEXTS.theme && !_themeId) {
+                renderOnce(React.createElement(MissingThemeIdError, null,
+                    React.createElement(Box, { flexDirection: "column", gap: 1 },
+                        React.createElement(Text, null, "Usage: shoper theme info [ID]"),
+                        React.createElement(Text, null, "Please run this command inside a theme directory or provide a theme ID."))));
+                return;
+            }
+            if (executionContext.type === EXECUTION_CONTEXTS.theme) {
+                await ThemeMetaDataUtils.ensureThemeWorkUrlMatch(executionContext.themeRootDir, credentials.shopUrl);
+                _themeId = themeId ?? executionContext.themeId;
+            }
+            if (!_themeId) {
+                renderOnce(React.createElement(MissingThemeIdError, null));
+                return;
+            }
+            const theme = await themesListApi.getTheme({
+                themeId: _themeId,
+                shopUrl: credentials.shopUrl
+            });
+            if (!theme) {
+                renderOnce(_themeId ? React.createElement(InvalidThemeIdError, { themeId: _themeId }) : React.createElement(Error, { header: "Error: Theme information is not available." }));
+                return;
+            }
+            this._displayThemeInfo(theme);
+        }
+        catch (err) {
+            this._handleError(err);
+        }
+    }
+    _handleError(err) {
+        if (err?.code === THEME_WORK_URL_MISMATCH_ERROR) {
+            renderOnce(React.createElement(ThemeWorkUrlMismatch, { command: "info" }));
+            return;
+        }
+        if (err?.message) {
+            renderOnce(React.createElement(Error, null,
+                React.createElement(Text, null, err.message)));
+            return;
+        }
+        this.error(String(err));
+    }
+    _displayThemeInfo(theme) {
+        renderOnce(React.createElement(Table, { data: ThemeInfoCommandUtils.mapThemeMetaDataToTableData(theme) }));
+    }
+}