@shoper/cli 0.1.0-3 → 0.1.0-31

package/bin/run.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import 'reflect-metadata';
 
 import { runCLI } from '../build/index.js';
 

package/build/cli/auth/api/cli_auth_api.js

@@ -0,0 +1,16 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { CLI_AUTH_API_NAME } from '../cli_auth_constants.js';
+export class CliAuthApi extends FeatureApi {
+    moduleName = CLI_AUTH_API_NAME;
+    #cliAuthService;
+    constructor(cliAuthService) {
+        super();
+        this.#cliAuthService = cliAuthService;
+    }
+    getCredentials() {
+        return this.#cliAuthService.getCredentials();
+    }
+    hasCredentialsExpired() {
+        return this.#cliAuthService.hasCredentialsExpired();
+    }
+}

package/build/cli/auth/cli_auth_constants.js

@@ -0,0 +1,6 @@
+export const CLI_AUTH_SCOPES = {
+    theme: 'theme',
+    app: 'app'
+};
+export const CLI_AUTH_FEATURE_NAME = 'CliAuth';
+export const CLI_AUTH_API_NAME = 'CliAuthApi';

package/build/cli/auth/cli_auth_errors_factory.js

@@ -0,0 +1,10 @@
+import { AppError } from '../class/errors/app/app_error.js';
+export class CliAuthErrorsFactory {
+    static createCredentialNotFoundError() {
+        return new AppError({
+            code: 'cli_auth.credential_not_found',
+            message: 'Credential not found',
+            level: 'error'
+        });
+    }
+}

package/build/cli/auth/cli_auth_initializer.js

@@ -0,0 +1,19 @@
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { CliAuthService } from './service/cli_auth_service.js';
+import { CliAuthApi } from './api/cli_auth_api.js';
+import { CLI_AUTH_TOKENS_API_NAME } from './tokens/cli_auth_tokens_constants.js';
+import { CLI_AUTH_FEATURE_NAME } from './cli_auth_constants.js';
+export class CliAuthInitializer extends SyncFeatureInitializer {
+    static featureName = CLI_AUTH_FEATURE_NAME;
+    init() {
+        const cliAuthTokensApi = this.getApiSync(CLI_AUTH_TOKENS_API_NAME);
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new CliAuthApi(new CliAuthService(cliAuthTokensApi))
+                }
+            ]
+        };
+    }
+}

package/build/cli/auth/cli_auth_utils.js

@@ -0,0 +1,22 @@
+import { CLI_AUTH_SCOPES } from './cli_auth_constants.js';
+export class CliAuthUtils {
+    static checkCredentials(credentialsApi, command) {
+        const credentials = credentialsApi.getCredentials();
+        if (!credentials)
+            return false;
+        if (credentialsApi.hasCredentialsExpired()) {
+            console.log('Credentials are expired, please reauthorize');
+            return false;
+        }
+        return CliAuthUtils.ensureScopeAccessRights(credentials.scopes, command.id);
+    }
+    // We assume for now that scopes names are same as topics names
+    static ensureScopeAccessRights(tokenScopes, commandId) {
+        if (!CliAuthUtils.isScopedCommand(Object.values(CLI_AUTH_SCOPES), commandId))
+            return true;
+        return CliAuthUtils.isScopedCommand(tokenScopes, commandId);
+    }
+    static isScopedCommand(scopes, commandId) {
+        return scopes.some((scope) => commandId.includes(scope));
+    }
+}

package/build/cli/auth/model/cli_credentials.js

@@ -0,0 +1,10 @@
+export class CliCredentials {
+    shopUrl;
+    scopes;
+    expires;
+    constructor({ shopUrl, scopes, expires }) {
+        this.expires = expires;
+        this.shopUrl = shopUrl;
+        this.scopes = scopes;
+    }
+}

package/build/cli/auth/service/cli_auth_service.js

@@ -0,0 +1,34 @@
+import { CliCredentials } from '../model/cli_credentials.js';
+import { CliAuthErrorsFactory } from '../cli_auth_errors_factory.js';
+export class CliAuthService {
+    #cliAuthTokensApi;
+    #credentials = null;
+    constructor(cliAuthTokensApi) {
+        this.#cliAuthTokensApi = cliAuthTokensApi;
+        this._setCredentials();
+    }
+    _setCredentials() {
+        const defaultTokenPayload = this.#cliAuthTokensApi.getDefaultTokenPayload();
+        if (!defaultTokenPayload)
+            return;
+        this.#credentials = new CliCredentials({
+            shopUrl: defaultTokenPayload.iss,
+            scopes: defaultTokenPayload.scope.split(';'),
+            expires: defaultTokenPayload.exp
+        });
+    }
+    getCredentials() {
+        if (this.#credentials)
+            return this.#credentials;
+        this._setCredentials();
+        return this.#credentials;
+    }
+    hasCredentialsExpired() {
+        if (!this.#credentials)
+            throw CliAuthErrorsFactory.createCredentialNotFoundError();
+        const defaultTokenIndex = this.#cliAuthTokensApi.getDefaultTokenIndex();
+        if (!defaultTokenIndex)
+            return true;
+        return this.#cliAuthTokensApi.hasTokenExpired(defaultTokenIndex);
+    }
+}

package/build/cli/auth/tokens/api/cli_auth_tokens_api.js

@@ -0,0 +1,43 @@
+import { CLI_AUTH_TOKENS_API_NAME } from '../cli_auth_tokens_constants.js';
+import { FeatureApi } from '@dreamcommerce/star_core';
+export class CliAuthTokensApi extends FeatureApi {
+    moduleName = CLI_AUTH_TOKENS_API_NAME;
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    addToken(token) {
+        this.#service.addToken(token);
+    }
+    removeToken(index) {
+        this.#service.removeToken(index);
+    }
+    setDefaultToken(index) {
+        this.#service.setDefaultToken(index);
+    }
+    getTokenPayload(index) {
+        return this.#service.getTokenPayload(index);
+    }
+    hasToken(index) {
+        return this.#service.hasToken(index);
+    }
+    getAllTokensPayloads() {
+        return this.#service.getAllTokensPayloads();
+    }
+    getDefaultTokenIndex() {
+        return this.#service.getDefaultTokenIndex();
+    }
+    getDefaultToken() {
+        return this.#service.getDefaultToken();
+    }
+    getDefaultTokenPayload() {
+        return this.#service.getDefaultTokenPayload();
+    }
+    hasTokenExpired(index) {
+        return this.#service.hasTokenExpired(index);
+    }
+    getTokensCount() {
+        return this.#service.getTokensCount();
+    }
+}

package/build/cli/auth/tokens/cli_auth_tokens_constants.js

@@ -0,0 +1,6 @@
+export const CLI_AUTH_TOKENS_API_NAME = 'CliAuthTokensApi';
+export const CLI_AUTH_TOKENS_FEATURE_NAME = 'CliAuthTokens';
+export const CLI_AUTH_TOKENS_TYPES = {
+    jwt: 'jwt'
+};
+export const CLI_AUTH_TOKENS_FILE_NAME = 'credentials';

package/build/cli/auth/tokens/cli_auth_tokens_errors_factory.js

@@ -0,0 +1,10 @@
+import { AppError } from '../../class/errors/app/app_error.js';
+export class CliAuthTokensErrorsFactory {
+    static createTokenNotFoundError(index) {
+        return new AppError({
+            code: 'cli_auth_tokens.token_not_found',
+            message: `Token with index "${index}" not found`,
+            level: 'error'
+        });
+    }
+}

package/build/cli/auth/tokens/cli_auth_tokens_initalizer.js

@@ -0,0 +1,35 @@
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { CliAuthTokensApi } from './api/cli_auth_tokens_api.js';
+import { CLiAuthTokensService } from './service/cli_auth_tokens_service.js';
+import { CLI_AUTH_TOKENS_FEATURE_NAME, CLI_AUTH_TOKENS_FILE_NAME } from './cli_auth_tokens_constants.js';
+import { CLI_DATA_DIRECTORY_API_NAME } from '../../features/data_directory/cli_data_directory_constants.js';
+import { JsonCache } from '../../features/caches/json_cache/json_cache.js';
+// schema
+// {
+//     default: string;
+//     tokens: {
+//          [key: string]: {
+//              type: string;
+//              token: string;
+//              expires: string;
+//         }
+//     }
+export class CliAuthTokensInitializer extends SyncFeatureInitializer {
+    static featureName = CLI_AUTH_TOKENS_FEATURE_NAME;
+    init() {
+        const cliDataDirectoryApi = this.getApiSync(CLI_DATA_DIRECTORY_API_NAME);
+        const tokensStore = new JsonCache({
+            path: cliDataDirectoryApi.getDataDirectoryFullPath(),
+            configFileMode: 0o600,
+            name: CLI_AUTH_TOKENS_FILE_NAME
+        });
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new CliAuthTokensApi(new CLiAuthTokensService(tokensStore))
+                }
+            ]
+        };
+    }
+}

package/build/cli/auth/tokens/cli_auth_tokens_utils.js

@@ -0,0 +1,26 @@
+import jwt from 'jsonwebtoken';
+export class CLiAuthTokensUtils {
+    static getTokenPayload(token) {
+        try {
+            return jwt.decode(token);
+        }
+        catch (err) {
+            console.error('Error decoding token:', err);
+            throw new Error('Invalid token');
+        }
+    }
+    static getTokenName(token) {
+        const payload = this.getTokenPayload(token);
+        const tokenName = payload?.name;
+        if (!tokenName) {
+            throw new Error('Token name not found in payload');
+        }
+        return tokenName;
+    }
+    static hasTokenExpired(token) {
+        const tokenPayload = CLiAuthTokensUtils.getTokenPayload(token);
+        if (!tokenPayload)
+            return true;
+        return tokenPayload.exp - Math.floor(Date.now() / 1000) < 0;
+    }
+}

package/build/cli/auth/tokens/service/cli_auth_tokens_service.js

@@ -0,0 +1,86 @@
+import { CLI_AUTH_TOKENS_TYPES } from '../cli_auth_tokens_constants.js';
+import { CLiAuthTokensUtils } from '../cli_auth_tokens_utils.js';
+import { CLI_AUTH_DEFAULT_TOKEN_NAME, CLI_AUTH_TOKENS_KEY } from './cli_auth_tokens_service_constants.js';
+import { CliAuthTokensErrorsFactory } from '../cli_auth_tokens_errors_factory.js';
+export class CLiAuthTokensService {
+    #tokensStore;
+    constructor(tokensStore) {
+        this.#tokensStore = tokensStore;
+    }
+    addToken(token) {
+        const tokeItem = {
+            token,
+            type: CLI_AUTH_TOKENS_TYPES.jwt
+        };
+        const tokens = this._getTokenItems() ?? [];
+        tokens.push(tokeItem);
+        this._setTokens(tokens);
+    }
+    hasToken(index) {
+        return index <= this.getTokensCount();
+    }
+    removeToken(index) {
+        if (!this.hasToken(index))
+            return;
+        const tokens = this._getTokenItems();
+        const newTokens = tokens.filter((_, currIndex) => currIndex !== index - 1);
+        this._setTokens(newTokens);
+    }
+    getDefaultTokenPayload() {
+        const defaultTokenIndex = this.getDefaultTokenIndex();
+        if (!defaultTokenIndex)
+            return null;
+        return this.getTokenPayload(defaultTokenIndex);
+    }
+    getDefaultTokenIndex() {
+        return this.#tokensStore.get(CLI_AUTH_DEFAULT_TOKEN_NAME);
+    }
+    getTokenPayload(index) {
+        const tokenItem = this._getTokenItem(index - 1);
+        if (!tokenItem)
+            return null;
+        return CLiAuthTokensUtils.getTokenPayload(tokenItem.token);
+    }
+    hasTokenExpired(index) {
+        const tokenItem = this._getTokenItem(index - 1);
+        if (!tokenItem)
+            return true;
+        return CLiAuthTokensUtils.hasTokenExpired(tokenItem.token);
+    }
+    /**
+     * Index starts from 1
+     */
+    setDefaultToken(index) {
+        const tokens = this._getTokenItems();
+        if (tokens.length < index)
+            throw CliAuthTokensErrorsFactory.createTokenNotFoundError(index);
+        this.#tokensStore.set(CLI_AUTH_DEFAULT_TOKEN_NAME, index);
+    }
+    _getTokenItems() {
+        return this.#tokensStore.get(CLI_AUTH_TOKENS_KEY) ?? [];
+    }
+    _getTokenItem(index) {
+        const tokens = this._getTokenItems();
+        return tokens[index] ?? null;
+    }
+    _setTokens(tokens) {
+        this.#tokensStore.set(CLI_AUTH_TOKENS_KEY, tokens);
+    }
+    getTokensCount() {
+        const tokens = this._getTokenItems();
+        return tokens.length;
+    }
+    getDefaultToken() {
+        const defaultTokenIndex = this.getDefaultTokenIndex();
+        if (!defaultTokenIndex)
+            return null;
+        const tokenItem = this._getTokenItem(defaultTokenIndex - 1);
+        if (!tokenItem)
+            return null;
+        return tokenItem.token;
+    }
+    getAllTokensPayloads() {
+        const tokens = this._getTokenItems();
+        return tokens.map((tokenItem) => CLiAuthTokensUtils.getTokenPayload(tokenItem.token));
+    }
+}

package/build/cli/auth/tokens/service/cli_auth_tokens_service_constants.js

@@ -0,0 +1,2 @@
+export const CLI_AUTH_DEFAULT_TOKEN_NAME = 'default';
+export const CLI_AUTH_TOKENS_KEY = 'tokens';

package/build/cli/class/base_cli_command.js

@@ -0,0 +1,3 @@
+import { BaseCommand } from './base_command.js';
+export class BaseCliCommand extends BaseCommand {
+}

package/build/cli/class/errors/app/app_error.js

@@ -0,0 +1,17 @@
+import { APP_ERRORS_LEVELS } from './app_error_constants.js';
+//TODO errory do zaprojektownia
+export class AppError extends Error {
+    code;
+    level;
+    tags;
+    details;
+    stack;
+    constructor({ code, details, message, level = APP_ERRORS_LEVELS.error, tags, stack }) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.level = level;
+        this.tags = tags;
+        this.stack = stack;
+    }
+}

package/build/cli/class/errors/app/app_error_constants.js

@@ -0,0 +1,7 @@
+export const APP_ERRORS_LEVELS = {
+    fatal: 'fatal',
+    error: 'error',
+    warn: 'warn',
+    info: 'info',
+    debug: 'debug'
+};

package/build/cli/class/errors/file_system_errors_factory.js

@@ -0,0 +1,26 @@
+import { AppError } from './app/app_error.js';
+export class FileSystemErrorsFactory {
+    static createDiskFullError() {
+        return new AppError({
+            code: 'file_system.disk_full',
+            message: 'Disk is full',
+            level: 'error'
+        });
+    }
+    static createErrorMovingFile(source, destination, err) {
+        return new AppError({
+            code: 'file_system.error_moving_file',
+            message: `Failed to move file from ${source} to ${destination}`,
+            level: 'error',
+            stack: err.stack
+        });
+    }
+    static createErrorCopyingFile(source, destination, err) {
+        return new AppError({
+            code: 'file_system.error_copying_file',
+            message: `Failed to copy file from ${source} to ${destination}`,
+            level: 'error',
+            stack: err.stack
+        });
+    }
+}

package/build/cli/class/errors/http/http_errors_constants.js

@@ -0,0 +1 @@
+export const HTTP_NOT_FOUND_ERROR_CODE = 'not_found';

package/build/cli/class/errors/http/http_errors_factory.js

@@ -0,0 +1,22 @@
+import { AppError } from '../app/app_error.js';
+import { HTTP_NOT_FOUND_ERROR_CODE } from './http_errors_constants.js';
+export class HttpErrorsFactory {
+    static createUnauthorizedError() {
+        return new AppError({
+            message: 'Unauthorized',
+            code: 'unauthorized'
+        });
+    }
+    static createForbiddenError() {
+        return new AppError({
+            message: 'Forbidden',
+            code: 'forbidden'
+        });
+    }
+    static createNotFoundError() {
+        return new AppError({
+            message: 'Not found',
+            code: HTTP_NOT_FOUND_ERROR_CODE
+        });
+    }
+}

package/build/cli/cli_constants.js

@@ -0,0 +1,2 @@
+export const CLI_NAME = '@shoper/cli';
+export const JSON_FILE_INDENT = 4;

package/build/cli/commands/auth/cli_auth_add_token_command.js

@@ -0,0 +1,35 @@
+import { BaseCliCommand } from '../../class/base_cli_command.js';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
+import { promptInput } from '../../../ui/prompts/prompt_input.js';
+import { renderOnce } from '../../../ui/ui_utils.js';
+import { Success } from '../../../ui/message_box/success.js';
+import { Text } from '../../../ui/text.js';
+import { Box } from '../../../ui/box.js';
+import { Command } from '../../../ui/command.js';
+import React from 'react';
+import { Error } from '../../../ui/message_box/error.js';
+export class CliAuthAddTokenCommand extends BaseCliCommand {
+    static summary = 'Adds a new authentication token and saves it locally.';
+    static description = 'The added token will be set as your default authentication token.\n\nUse this when you’ve generated a token in your store panel and want to authenticate your CLI commands.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const cliAuthTokensApi = this.getApi(CLI_AUTH_TOKENS_API_NAME);
+        try {
+            const { input: token } = await promptInput('Please paste your CLI token:');
+            cliAuthTokensApi.addToken(token);
+            cliAuthTokensApi.setDefaultToken(cliAuthTokensApi.getTokensCount());
+            renderOnce(React.createElement(Success, null,
+                React.createElement(Text, null, "Token saved locally and set as your default. You can now authenticate using this token."),
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        "Run ",
+                        React.createElement(Command, null, "shoper auth list-tokens"),
+                        " to view your saved tokens."))));
+        }
+        catch (err) {
+            renderOnce(React.createElement(Error, { header: "Error: Failed to add token: " },
+                React.createElement(Box, null,
+                    React.createElement(Text, null, err.toString()))));
+        }
+    }
+}

package/build/cli/commands/auth/cli_auth_commands_constants.js

@@ -0,0 +1,3 @@
+export const TOKEN_SCOPE_TO_DESCRIPTION = {
+    theme: 'Edit store themes'
+};

package/build/cli/commands/auth/cli_auth_commands_utils.js

@@ -0,0 +1,46 @@
+import { Text } from '../../../ui/text.js';
+import { TOKEN_SCOPE_TO_DESCRIPTION } from './cli_auth_commands_constants.js';
+import { CSS_BACKGROUND_COLORS, CSS_TEXT_COLORS } from '../../../ui/color_constants.js';
+import { DateUtils } from '@dreamcommerce/utilities';
+import React from 'react';
+export class CliAuthCommandsUtils {
+    static mapToTableData(data, defaultIndex, tokensApi) {
+        return {
+            headers: [
+                {
+                    content: 'Index',
+                    width: 10
+                },
+                {
+                    content: 'Token Name',
+                    width: 40
+                },
+                {
+                    content: 'Store',
+                    width: 40
+                },
+                {
+                    content: 'Access Scope',
+                    width: 20
+                },
+                {
+                    content: 'Valid until',
+                    width: 20
+                }
+            ],
+            rows: data.map((tokenData, index) => {
+                const tokenIndex = index + 1;
+                const isDefault = defaultIndex !== null && tokenIndex === defaultIndex;
+                const tokenName = isDefault ? React.createElement(Text, { bold: true }, `${tokenData.name} (Default)`) : tokenData.name;
+                const hasExpired = tokensApi.hasTokenExpired(tokenIndex);
+                return [
+                    React.createElement(Text, { bold: isDefault }, tokenIndex),
+                    tokenName,
+                    React.createElement(Text, { bold: isDefault }, tokenData.iss),
+                    TOKEN_SCOPE_TO_DESCRIPTION[tokenData.scope],
+                    React.createElement(Text, { color: hasExpired ? CSS_TEXT_COLORS.invert : undefined, backgroundColor: hasExpired ? CSS_BACKGROUND_COLORS.danger : undefined }, DateUtils.toLocaleDate(new Date(tokenData.exp * 1000), 'pl-PL'))
+                ];
+            })
+        };
+    }
+}

package/build/cli/commands/auth/cli_auth_list_tokens_command.js

@@ -0,0 +1,30 @@
+import { BaseCliCommand } from '../../class/base_cli_command.js';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
+import React from 'react';
+import { CliAuthCommandsUtils } from './cli_auth_commands_utils.js';
+import { Table } from '../../../ui/table/table.js';
+import { render } from '../../../ui/ui_utils.js';
+import { Box } from '../../../ui/box.js';
+import { Tip } from '../../../ui/tip.js';
+import { Command } from '../../../ui/command.js';
+import { Text } from '../../../ui/text.js';
+import { Info } from '../../../ui/message_box/info.js';
+export class CliAuthListTokensCommand extends BaseCliCommand {
+    static summary = 'Displays a list of all authentication tokens stored locally.';
+    static description = 'For each token, you’ll see its name, index, assigned store URL, access scope and expiration date.\n\nUse this to review your tokens and check which one is set as the default.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const tokensApi = this.getApi(CLI_AUTH_TOKENS_API_NAME);
+        const tokensPayloads = tokensApi.getAllTokensPayloads();
+        if (!tokensPayloads.length) {
+            await render(React.createElement(Info, null,
+                React.createElement(Box, null,
+                    React.createElement(Text, null, "No tokens found")),
+                React.createElement(Tip, null,
+                    "Generate one using ",
+                    React.createElement(Command, null, "shoper auth add-token"))));
+            return;
+        }
+        await render(React.createElement(Table, { data: CliAuthCommandsUtils.mapToTableData(tokensPayloads, tokensApi.getDefaultTokenIndex(), tokensApi) }));
+    }
+}

package/build/cli/commands/auth/cli_auth_remove_token_command.js

@@ -0,0 +1,63 @@
+import { BaseCliCommand } from '../../class/base_cli_command.js';
+import { Args } from '@oclif/core';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
+import { renderOnce } from '../../../ui/ui_utils.js';
+import { MissingTokenIndexError } from './ui/missing_token_index_error.js';
+import { InvalidTokenIndexError } from './ui/invalid_token_index_error.js';
+import React from 'react';
+import { Text } from '../../../ui/text.js';
+import { Command } from '../../../ui/command.js';
+import { Box } from '../../../ui/box.js';
+import { promptConfirmation } from '../../../ui/prompts/prompt_confirmation.js';
+import { Info } from '../../../ui/message_box/info.js';
+import { Success } from '../../../ui/message_box/success.js';
+import { Warning } from '../../../ui/message_box/warning.js';
+import { Error } from '../../../ui/message_box/error.js';
+export class CliAuthRemoveTokenCommand extends BaseCliCommand {
+    static summary = 'Removes a locally saved authentication token.';
+    static description = 'Use this to clean up tokens you no longer need.';
+    static examples = [
+        {
+            description: 'Remove token with index 2',
+            command: '<%= config.bin %> <%= command.id %> 2'
+        }
+    ];
+    static args = {
+        index: Args.integer({
+            description: 'Index of the token to remove',
+            required: false
+        })
+    };
+    async run() {
+        const cliAuthTokensApi = this.getApi(CLI_AUTH_TOKENS_API_NAME);
+        const data = await this.parse(CliAuthRemoveTokenCommand);
+        const { args } = data;
+        const { index } = args;
+        if (!index || !cliAuthTokensApi.hasToken(index)) {
+            renderOnce(React.createElement(MissingTokenIndexError, { command: React.createElement(Command, null, "shoper auth remove-token [TOKEN_INDEX]") }));
+            return;
+        }
+        const token = cliAuthTokensApi.getTokenPayload(index);
+        if (!token) {
+            renderOnce(React.createElement(InvalidTokenIndexError, null));
+            return;
+        }
+        try {
+            renderOnce(React.createElement(Warning, { header: `Warning: This will permanently delete the token "${token.name}" assigned to "${token.iss}". This action cannot be undone.` }));
+            const { proceed } = await promptConfirmation('Proceed?');
+            if (proceed) {
+                cliAuthTokensApi.removeToken(index);
+                cliAuthTokensApi.setDefaultToken(cliAuthTokensApi.getTokensCount());
+                renderOnce(React.createElement(Success, { header: `Success: Token "${token.name}" has been removed.` }));
+                return;
+            }
+            renderOnce(React.createElement(Info, null,
+                React.createElement(Text, null, "Token removal was cancelled.")));
+        }
+        catch (err) {
+            renderOnce(React.createElement(Error, { header: "Error: Failed to remove token: " },
+                React.createElement(Box, null,
+                    React.createElement(Text, null, err.toString()))));
+        }
+    }
+}