@shoper/cli 0.1.0-9 → 0.2.0

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

@@ -0,0 +1,39 @@
+import { Text } from '../../../ui/text.js';
+import React from 'react';
+export class ThemeInfoCommandUtils {
+    static mapThemeMetaDataToTableData(theme) {
+        return {
+            headers: [
+                {
+                    content: 'Theme Info'
+                }
+            ],
+            rows: [
+                [
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "ID:"),
+                        " ",
+                        theme.skinId)
+                ],
+                [
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "Name:"),
+                        " ",
+                        theme.title)
+                ],
+                [
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "Description:"),
+                        " ",
+                        theme.description ? theme.description : '-')
+                ],
+                [
+                    React.createElement(Text, null,
+                        React.createElement(Text, { bold: true }, "Status: "),
+                        ": ",
+                        theme.isActive ? 'Active' : 'Inactive')
+                ]
+            ]
+        };
+    }
+}

package/build/theme/commands/init/theme_init_command.js

@@ -0,0 +1,97 @@
+import { BaseThemeCommand } from '../../class/base_theme_command.js';
+import { Args } from '@oclif/core';
+import { THEME_INIT_API_NAME } from '../../features/theme/init/theme_init_constants.js';
+import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
+import ora from 'ora';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_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 { renderOnce } from '../../../ui/ui_utils.js';
+import { ThemeDirectoryContextError } from '../ui/theme_directory_context_error.js';
+import React from 'react';
+import { UnpermittedCommandError } from '../ui/unpermitted_command_error.js';
+import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
+import { ThemeCreatedSuccess } from './ui/theme_created_success.js';
+import { Text } from '../../../ui/text.js';
+import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
+import { Box } from '../../../ui/box.js';
+import { ValidationErrors } from '../../../ui/validation_errors/validation_errors.js';
+export class ThemeInitCommand extends BaseThemeCommand {
+    static summary = 'Creates a copy of an existing theme by duplicating it.';
+    static description = 'The new theme will be named after the source theme with a "Copy" suffix and an incremental number.\n\nYou must run this command from the root directory (not inside any theme folder) and provide the ID of the theme you want to duplicate.';
+    static examples = [
+        {
+            description: 'This will duplicate the theme with ID 123 (named SourceTheme Copy 3) and create a new theme named "SourceTheme Copy 4".\nUse this as a starting point for your customizations.\n',
+            command: '<%= config.bin %> <%= command.id %> 123'
+        }
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Theme id',
+            name: 'id',
+            required: false,
+            type: 'string'
+        })
+    };
+    async run() {
+        const data = await this.parse(ThemeInitCommand);
+        const { args } = data;
+        const themeId = args.id;
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const themeInitApi = this.getApi(THEME_INIT_API_NAME);
+        const themeActionsApi = this.getApi(THEME_ACTIONS_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();
+        if (executionContext.type === EXECUTION_CONTEXTS.theme) {
+            renderOnce(React.createElement(ThemeDirectoryContextError, null));
+            return;
+        }
+        if (!themeId) {
+            this._renderMissingThemeIdError();
+            return;
+        }
+        let spinner;
+        try {
+            const copyAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.copy,
+                themeId,
+                credentials
+            });
+            if (!copyAction) {
+                renderOnce(React.createElement(UnpermittedCommandError, { themeId: themeId, commandName: "init" }));
+                return;
+            }
+            spinner = ora('Creating theme...').start();
+            const { themeId: createdThemeId, themeName } = await themeInitApi.initTheme({ action: copyAction, credentials });
+            spinner.stop();
+            renderOnce(React.createElement(ThemeCreatedSuccess, { createdThemeId: createdThemeId, themeName: themeName }));
+        }
+        catch (err) {
+            spinner?.stop();
+            this._handleError(err, themeId);
+            //TODO analyze why on nodejs v22 this command does not exit properly, even all promises are resolved
+            this.exit();
+        }
+    }
+    _handleError(err, themeId) {
+        if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE && themeId) {
+            renderOnce(React.createElement(UnpermittedCommandError, { themeId: themeId, commandName: "init" }));
+            return;
+        }
+        if (err?.message) {
+            renderOnce(React.createElement(ValidationErrors, { errors: err.message }));
+            return;
+        }
+        this.error(String(err));
+    }
+    _renderMissingThemeIdError() {
+        renderOnce(React.createElement(MissingThemeIdError, null,
+            React.createElement(Box, { flexDirection: "column", gap: 1 },
+                React.createElement(Text, null, "Usage: shoper theme init [ID]"),
+                React.createElement(Text, null, "This command creates a copy of an existing theme based on its ID.To proceed, you must provide the ID of the theme you want to duplicate."))));
+    }
+}

package/build/theme/commands/init/ui/theme_created_success.js

@@ -0,0 +1,15 @@
+import { Box } from '../../../../ui/box.js';
+import { Text } from '../../../../ui/text.js';
+import { Success } from '../../../../ui/message_box/success.js';
+import React from 'react';
+export const ThemeCreatedSuccess = ({ createdThemeId, themeName }) => {
+    return (React.createElement(Success, { header: "Success: Theme was created!" },
+        React.createElement(Box, { gap: 1, flexDirection: "column" },
+            React.createElement(Text, null,
+                "Theme \"",
+                themeName,
+                "\" was created (ID: ",
+                createdThemeId,
+                ")."),
+            React.createElement(Text, null, "You can now customize your new theme."))));
+};

package/build/theme/commands/list/theme_list_command.js

@@ -0,0 +1,25 @@
+import { BaseThemeCommand } from '../../class/base_theme_command.js';
+import { THEMES_LIST_API_NAME } from '../../features/themes/list/themes_list_constants.js';
+import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
+import { renderOnce } from '../../../ui/ui_utils.js';
+import { Info } from '../../../ui/message_box/info.js';
+import React from 'react';
+import { Table } from '../../../ui/table/table.js';
+import { ThemeListCommandUtils } from './theme_list_command_utils.js';
+export class ThemeListCommand extends BaseThemeCommand {
+    static summary = 'Displays a list of all themes available in your store, including their IDs, names, and statuses (active/inactive).';
+    static description = 'Use this to check which theme is now active in your store.';
+    async run() {
+        const ThemesListApi = this.getApi(THEMES_LIST_API_NAME);
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials)
+            this.error('Credentials not found. Please authorize first.');
+        const themes = await ThemesListApi.getThemes(credentials);
+        if (!themes?.length) {
+            renderOnce(React.createElement(Info, { header: "No themes found for this store." }));
+            return;
+        }
+        renderOnce(React.createElement(Table, { data: ThemeListCommandUtils.mapThemeListToTableData(themes) }));
+    }
+}

package/build/theme/commands/list/theme_list_command_utils.js

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Text } from '../../../ui/text.js';
+export class ThemeListCommandUtils {
+    static mapThemeListToTableData(themes) {
+        return {
+            headers: [
+                {
+                    content: 'Theme ID',
+                    width: 10
+                },
+                {
+                    content: 'Theme Name',
+                    width: 70
+                },
+                {
+                    content: 'Status',
+                    width: 10
+                }
+            ],
+            rows: themes.map((theme) => [
+                React.createElement(Text, null, theme.skinId),
+                React.createElement(Text, null, theme.title),
+                React.createElement(Text, null, theme.isActive ? 'active' : 'inactive')
+            ])
+        };
+    }
+}

package/build/theme/commands/publish/theme_publish_command.js

@@ -0,0 +1,92 @@
+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 { UnpermittedCommandError } from '../ui/unpermitted_command_error.js';
+import { Error } from '../../../ui/message_box/error.js';
+import { Text } from '../../../ui/text.js';
+import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
+import { THEME_SKINSTORE_API_NAME } from '../../features/theme/skinstore/theme_publish_constants.js';
+import { Form } from '../../../cli/features/controls/ui/form.js';
+export class ThemePublishCommand 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(ThemePublishCommand);
+        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) {
+                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 themeSkinstoreApi = this.getApi(THEME_SKINSTORE_API_NAME);
+            const pushAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.publishForm,
+                themeId: _themeId,
+                credentials
+            });
+            const controls = await themeSkinstoreApi.getPublishFormData({
+                actionData: pushAction.data,
+                credentials
+            });
+            Form({
+                controls,
+                onSubmit: (formData) => {
+                    console.log('formData', formData);
+                }
+            });
+        }
+        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/pull/theme_pull_command.js

@@ -0,0 +1,194 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseThemeCommand } from '../../class/base_theme_command.js';
+import { THEME_FETCH_API_NAME, THEME_FETCH_TYPES } from '../../features/theme/fetch/theme_fetch_constants.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 ora from 'ora';
+import { THEME_MERGE_API_NAME } from '../../features/theme/merge/theme_merge_constants.js';
+import tmp from 'tmp-promise';
+import { join } from '../../../utils/path_utils.js';
+import { THEME_ACTION_NOT_FOUND_ERROR_CODE, THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../../features/theme/actions/theme_actions_constants.js';
+import process from 'node:process';
+import { ThemeResourcesWithIdDirectoryUtils } from '../../features/theme/utils/resources/theme_resources_with_id_directory_utils.js';
+import { renderOnce } from '../../../ui/ui_utils.js';
+import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
+import React from 'react';
+import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
+import { Text } from '../../../ui/text.js';
+import { UnpermittedCommandError } from '../ui/unpermitted_command_error.js';
+import { ThemePullIdMismatchError } from './ui/theme_pull_id_mismatch_error.js';
+import { ThemePullUnpublishedChangesWarning } from './ui/theme_pull_unpublished_changes_warning.js';
+import { promptConfirmation } from '../../../ui/prompts/prompt_confirmation.js';
+import { ThemePulledSuccess } from './ui/theme_pulled_success.js';
+import { Info } from '../../../ui/message_box/info.js';
+import { directoryExists } from '../../../utils/fs/fs_utils.js';
+import { THEME_WORK_URL_MISMATCH_ERROR } from '../../features/theme/utils/meta_data/theme_meta_data_constants.js';
+import { ThemeWorkUrlMismatch } from '../ui/theme_work_url_mismatch.js';
+import { Error } from '../../../ui/message_box/error.js';
+import { ThemeMetaDataUtils } from '../../features/theme/utils/meta_data/theme_meta_data_utils.js';
+import { ThemeChecksums } from '../../class/checksums/theme_checksums.js';
+//TODO jak jest error w pullu wowczas usuwamy docelowo pociagniety skin
+export class ThemePullCommand extends BaseThemeCommand {
+    static summary = 'Downloads the current version of your theme from the store and overwrites your local theme files.';
+    static description = 'Make sure to back up any local modifications you wish to keep.\n\nYou can run this command from a specific theme directory (ID not needed) or outside any theme directory (theme ID required).\n\nThis keeps your local theme the same as the version in your store.';
+    static examples = [
+        {
+            description: 'This will update your local theme files with the current version from the store.',
+            command: '<%= config.bin %> <%= command.id %>'
+        },
+        {
+            description: 'This will download the theme with ID "2" from the store.',
+            command: '<%= config.bin %> <%= command.id %> 2'
+        }
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Theme id',
+            name: 'id',
+            type: 'string'
+        })
+    };
+    static flags = {
+        type: Flags.string({
+            default: THEME_FETCH_TYPES.full,
+            description: 'Type of theme to pull',
+            options: Object.values(THEME_FETCH_TYPES)
+        })
+    };
+    #spinner;
+    async run() {
+        const data = await this.parse(ThemePullCommand);
+        const { args, flags } = data;
+        const themeId = args.id;
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const themeFetchApi = this.getApi(THEME_FETCH_API_NAME);
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials) {
+            renderOnce(React.createElement(MissingCredentialsError, null));
+            return;
+        }
+        const executionContext = await executionContextApi.getExecutionContext();
+        let _themeId = themeId;
+        try {
+            if (executionContext.type !== EXECUTION_CONTEXTS.theme) {
+                await this._pullNewTheme({
+                    themeId,
+                    themeFetchApi,
+                    themeActionsApi,
+                    credentials,
+                    fetchType: flags.type
+                });
+            }
+            if (executionContext.type === EXECUTION_CONTEXTS.theme) {
+                _themeId = themeId ? themeId : executionContext.themeId;
+                await this._pullThemeIntoExistingOne({
+                    themeId: _themeId,
+                    themeFetchApi,
+                    themeActionsApi,
+                    fetchType: flags.type,
+                    executionContext,
+                    credentials
+                });
+            }
+        }
+        catch (err) {
+            this.#spinner?.stop();
+            this._handleError(err, _themeId);
+        }
+    }
+    _handleError(err, _themeId) {
+        if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE && _themeId) {
+            this._renderUnpermittedCommandError(_themeId);
+            return;
+        }
+        if (err?.code === THEME_WORK_URL_MISMATCH_ERROR) {
+            renderOnce(React.createElement(ThemeWorkUrlMismatch, { command: "pull" }));
+            return;
+        }
+        if (err?.message) {
+            renderOnce(React.createElement(Error, null,
+                React.createElement(Text, null, err.message)));
+            return;
+        }
+        this.error(String(err));
+    }
+    _renderUnpermittedCommandError(themeId) {
+        renderOnce(React.createElement(UnpermittedCommandError, { themeId: themeId, commandName: "pull" }));
+    }
+    async _pullNewTheme({ themeId, themeFetchApi, themeActionsApi, credentials, fetchType }) {
+        if (themeId === undefined) {
+            renderOnce(React.createElement(MissingThemeIdError, null,
+                React.createElement(Text, null, "Usage: shoper theme pull [ID]")));
+            return;
+        }
+        const pullAction = themeActionsApi.getThemeAction({
+            actionType: THEME_ACTIONS_TYPES.pull,
+            themeId,
+            credentials
+        });
+        if (!pullAction) {
+            this._renderUnpermittedCommandError(themeId);
+            return;
+        }
+        this.#spinner = ora('Pulling theme...').start();
+        await themeFetchApi.fetchTheme({
+            credentials,
+            action: pullAction,
+            config: {
+                dist: process.cwd(),
+                fetchType
+            }
+        });
+        this.#spinner.stop();
+        renderOnce(React.createElement(ThemePulledSuccess, null));
+    }
+    async _pullThemeIntoExistingOne({ themeId, themeFetchApi, themeActionsApi, fetchType, executionContext, credentials }) {
+        //TODO move these logi somvewhere else?
+        await ThemeMetaDataUtils.ensureThemeWorkUrlMatch(executionContext.themeRootDir, credentials.shopUrl);
+        const pullAction = themeActionsApi.getThemeAction({
+            actionType: THEME_ACTIONS_TYPES.pull,
+            themeId,
+            credentials
+        });
+        if (!pullAction) {
+            this._renderUnpermittedCommandError(themeId);
+            return;
+        }
+        if (executionContext.themeId !== themeId) {
+            renderOnce(React.createElement(ThemePullIdMismatchError, { providedThemeId: themeId, currentThemeId: executionContext.themeId }));
+            return;
+        }
+        const themeMergeApi = this.getApi(THEME_MERGE_API_NAME);
+        const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+        this.#spinner = ora('Pulling theme...').start();
+        const { name } = await themeFetchApi.fetchTheme({
+            credentials,
+            action: pullAction,
+            config: {
+                fetchType,
+                dist: tmpDir
+            }
+        });
+        const localModulesPath = join(executionContext.themeRootDir, 'modules');
+        const fetchedThemePath = join(tmpDir, name);
+        const fetchedModulesPath = join(fetchedThemePath, 'modules');
+        if ((await directoryExists(localModulesPath)) && (await directoryExists(fetchedModulesPath)))
+            await ThemeResourcesWithIdDirectoryUtils.updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localModulesPath, fetchedModulesPath, fetchedThemePath);
+        this.#spinner.stop();
+        const changes = await themeMergeApi.getChangesBetweenThemes(fetchedThemePath, executionContext.themeRootDir);
+        const themeChecksums = new ThemeChecksums(executionContext.themeRootDir);
+        if (changes.length && (await themeChecksums.hasThemeBeenModified())) {
+            renderOnce(React.createElement(ThemePullUnpublishedChangesWarning, { changes: changes }));
+            const { proceed } = await promptConfirmation('Do you want to continue and overwrite local changes?');
+            if (!proceed) {
+                renderOnce(React.createElement(Info, null,
+                    React.createElement(Text, null, "Pull operation cancelled. Your local changes are safe.")));
+                return;
+            }
+        }
+        await themeMergeApi.applyChanges(join(tmpDir, name), executionContext.themeRootDir, changes);
+        renderOnce(React.createElement(ThemePulledSuccess, null));
+    }
+}

package/build/theme/commands/pull/ui/theme_pull_id_mismatch_error.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Error } from '../../../../ui/message_box/error.js';
+import { Text } from '../../../../ui/text.js';
+export const ThemePullIdMismatchError = ({ providedThemeId, currentThemeId }) => {
+    return (React.createElement(Error, { header: `Error: Provided ID (${providedThemeId}) doesn't match the current theme directory (${currentThemeId}).` },
+        React.createElement(Text, null, "Please move outside the theme directory and run the command again with the correct ID.")));
+};

package/build/theme/commands/pull/ui/theme_pull_unpublished_changes_warning.js

@@ -0,0 +1,10 @@
+import { Warning } from '../../../../ui/message_box/warning.js';
+import { List } from '../../../../ui/list/list.js';
+import React from 'react';
+export const ThemePullUnpublishedChangesWarning = ({ changes }) => {
+    const items = changes.map(([action, path]) => ({
+        content: `${action} - ${path}`
+    }));
+    return (React.createElement(Warning, { header: "Warning: You have unpushed local changes in this theme directory. Pulling now may overwrite your local modifications." },
+        React.createElement(List, { items: items })));
+};

package/build/theme/commands/pull/ui/theme_pulled_success.js

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Success } from '../../../../ui/message_box/success.js';
+export const ThemePulledSuccess = () => {
+    return React.createElement(Success, { header: "Theme was pulled" });
+};

package/build/theme/commands/push/theme_push_command.js

@@ -0,0 +1,134 @@
+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 { THEME_ACTION_NOT_FOUND_ERROR_CODE, THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../../features/theme/actions/theme_actions_constants.js';
+import { THEME_ARCHIVE_UPLOAD_ERROR, THEME_FILES_UPLOAD_ERROR, THEME_PUSH_API_NAME } from '../../features/theme/push/theme_push_constants.js';
+import { ThemeMetaDataUtils } from '../../features/theme/utils/meta_data/theme_meta_data_utils.js';
+import { mapChecksumToTree } from '../../../utils/checksums/checksums_utils.js';
+import { mapToPermissionsTree } from '../../utils/directory_validator/directory_validator_utils.js';
+import { renderOnce } from '../../../ui/ui_utils.js';
+import { UnpermittedCommandError } from '../ui/unpermitted_command_error.js';
+import React from 'react';
+import { OutsideOfThemeDirectoryContextError } from '../ui/ouside_of_theme_directory_context_error.js';
+import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
+import { ThemePushedSuccess } from './ui/theme_pushed_success.js';
+import ora from 'ora';
+import { MissingThemeFiles } from '../ui/missing_theme_files.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.js';
+import { THEME_FILES_STRUCTURE_FILE_NAME } from '../../features/theme/theme_constants.js';
+import { ThemePushSkipInfo } from './ui/theme_push_skip_into.js';
+import { ThemeUnpermittedActionsError } from './ui/theme_unpermitted_actions_error.js';
+import { Error } from '../../../ui/message_box/error.js';
+import { Text } from '../../../ui/text.js';
+import { ThemeWorkUrlMismatch } from '../ui/theme_work_url_mismatch.js';
+import { THEME_WORK_URL_MISMATCH_ERROR } from '../../features/theme/utils/meta_data/theme_meta_data_constants.js';
+import { ThemeFilesStructureUtils } from '../../features/theme/utils/files_structure/theme_files_structure_utils.js';
+import { ThemeInfoUtils } from '../../features/theme/info/theme_info_utils.js';
+import { ValidationErrors } from '../../../ui/validation_errors/validation_errors.js';
+import { ThemeChecksums } from '../../class/checksums/theme_checksums.js';
+export class ThemePushCommand extends BaseThemeCommand {
+    static summary = 'Uploads your local theme files to the store and overwrites the current version of the theme in your store.';
+    static description = 'Check your local changes before pushing.\n\nYou must run this command from a specific theme directory (ID not needed).';
+    static examples = [
+        {
+            description: 'This will replace the store version with your local copy.',
+            command: '<%= config.bin %> <%= command.id %>'
+        }
+    ];
+    async run() {
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const themePushApi = this.getApi(THEME_PUSH_API_NAME);
+        const themeActionsApi = this.getApi(THEME_ACTIONS_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();
+        if (executionContext.type !== EXECUTION_CONTEXTS.theme) {
+            renderOnce(React.createElement(OutsideOfThemeDirectoryContextError, null));
+            return;
+        }
+        let spinner;
+        try {
+            const themeChecksums = new ThemeChecksums(executionContext.themeRootDir);
+            await ThemeMetaDataUtils.ensureThemeWorkUrlMatch(executionContext.themeRootDir, credentials.shopUrl);
+            const pushAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.push,
+                themeId: executionContext.themeId,
+                credentials
+            });
+            if (!pushAction) {
+                renderOnce(React.createElement(UnpermittedCommandError, { themeId: executionContext.themeId, commandName: "push" }));
+                return;
+            }
+            const initialChecksums = await themeChecksums.getInitialChecksums();
+            const permissions = await ThemeFilesStructureUtils.getFilesPermissions(executionContext.themeRootDir);
+            if (!initialChecksums || !permissions)
+                this.error('Theme checksums or permissions not found. Please ensure you are in the correct theme directory.');
+            if (!(await themeChecksums.hasThemeBeenModified())) {
+                renderOnce(React.createElement(ThemePushSkipInfo, null));
+                return;
+            }
+            const validationResult = await ThemeFilesStructureUtils.validateThemeDirectoryStructure({
+                //TDO przeniesc do theme checksums
+                checksums: mapChecksumToTree(initialChecksums),
+                permissions: mapToPermissionsTree(permissions),
+                rootDirectory: executionContext.themeRootDir
+            });
+            //TODO jak wysyla folder z nazwa posiadajaco \ na windows, wychodzimy
+            //TODO validacja folderów przed pushem
+            if (!validationResult.isValid) {
+                renderOnce(React.createElement(ThemeUnpermittedActionsError, { unpermittedActions: validationResult.unpermittedActions }));
+                return;
+            }
+            const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(executionContext.themeRootDir);
+            if (!filesStructure) {
+                renderOnce(React.createElement(MissingThemeFiles, { files: `${SHOPER_THEME_METADATA_DIR}/${THEME_FILES_STRUCTURE_FILE_NAME}` }));
+                return;
+            }
+            spinner = ora('Pushing theme...').start();
+            await themePushApi.push({
+                credentials,
+                filesStructure,
+                pushAction,
+                themeChecksums,
+                executionContext
+            });
+            spinner.stop();
+            renderOnce(React.createElement(ThemePushedSuccess, { themeName: await ThemeInfoUtils.getThemeName(executionContext.themeRootDir) }));
+        }
+        catch (err) {
+            spinner?.stop();
+            this._handleError(err, executionContext);
+        }
+    }
+    _handleError(err, executionContext) {
+        if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE) {
+            renderOnce(React.createElement(UnpermittedCommandError, { themeId: executionContext.themeId, commandName: "push" }));
+            return;
+        }
+        if (err?.code === THEME_ARCHIVE_UPLOAD_ERROR) {
+            renderOnce(React.createElement(ValidationErrors, { errors: err?.details }));
+            return;
+        }
+        if (err?.code === THEME_WORK_URL_MISMATCH_ERROR) {
+            this._renderUrlMismatchError();
+            return;
+        }
+        if (err?.code === THEME_FILES_UPLOAD_ERROR) {
+            renderOnce(React.createElement(Error, { header: "Uploading theme files to the shop failed.\n" },
+                React.createElement(Text, null, "The rejected files have been removed locally. Please ensure that the files are not corrupted and that the file extensions are supported.")));
+            return;
+        }
+        if (err?.message) {
+            renderOnce(React.createElement(ValidationErrors, { errors: err.message }));
+            return;
+        }
+        this.error(String(err));
+    }
+    _renderUrlMismatchError() {
+        renderOnce(React.createElement(ThemeWorkUrlMismatch, { command: "push" }));
+    }
+}