Melhore esse código e me envie COMPLETO

const JSZip = require('jszip');
const path = require('path');
const fs = require("fs");
const crypto = require('crypto');
const axios = require('axios');

const { EmbedBuilder, ActionRowBuilder, AttachmentBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, ButtonStyle, ButtonBuilder } = require('discord.js');

const { Cart, Application, Product } = require("../database/models/Models");
const { getBotUser } = require('../utils/functions');

module.exports = async (interaction, square_api) => {
    const [selectedPlan, daysPurchased, productId] = interaction.customId.split("_");

    if (interaction.isModalSubmit() && interaction.customId.endsWith("_redeem_modal")) {
        const productData = await Product.findById(productId);

        const nome = interaction.fields.getTextInputValue("nomeapp");
        const botToken = interaction.fields.getTextInputValue("tokenapp");
        const iddono = interaction.user.id

        const response = getBotUser(botToken)

        if (!response) return interaction.reply({
            content: `❌ | Token inválido. Verifique nosso tutorial.`,
            ephemeral: true
        })


        const botID = response.data.id;

        // Responde ao usuário informando que o Redeem Bot está sendo enviado
        await interaction.reply({
            content: "🔁 | Enviando o bot...",
            ephemeral: true
        });

        // Caminho para o arquivo zip original
        const originalZipPath = `source/${productId}.zip`;
        const clientDir = 'source/customers';
        const newZipFilename = `${crypto.randomBytes(5).toString("hex")}_${interaction.user.id}.zip`;
        const newZipPath = path.join(clientDir, newZipFilename);

        // Lê o arquivo zip original
        fs.readFile(originalZipPath, async function (err, data) {
            if (err) {
                console.error(err);
                return interaction.editReply({ content: "Erro ao ler o arquivo zip original." });
            }

            try {
                const envConfigName = 'env_config.json';

                const zip = await JSZip.loadAsync(data);

                const configFile = zip.file(envConfigName);
                if (!configFile) {
                    throw new Error("env_config.json não encontrado no zip.");
                }

                const configContent = await configFile.async('string');

                let config = JSON.parse(configContent);
                config.BOT_TOKEN = botToken;
                config.applicationOwner = iddono;

                zip.file(envConfigName, JSON.stringify(config, null, 2));

                const squareConfigFileName = zip.files['squarecloud.config'] ? 'squarecloud.config' : 'squarecloud.app';
                const squareConfigFile = zip.file(squareConfigFileName);
                if (squareConfigFile) {
                    let squareConfigContent = await squareConfigFile.async('string');
                    const items = {
                        DISPLAY_NAME: `${interaction.member.displayName} - ${crypto.randomBytes(4).toString('hex')}`,
                        DESCRIPTION: `${productData.productName} - ${productData.appType} - ${interaction.user.id}`,
                        AUTORESTART: true
                    };

                    for (const [key, value] of Object.entries(items)) {
                        const regex = new RegExp(`^${key}=.*$`, 'm');
                        if (squareConfigContent.match(regex)) {
                            squareConfigContent = squareConfigContent.replace(regex, `${key}=${value}`);
                        } else {
                            squareConfigContent += `\n${key}=${value}`;
                        }
                    }

                    zip.file(squareConfigFileName, squareConfigContent);
                } else {
                    throw new Error(`${squareConfigFileName} não encontrado no zip.`);
                }

                const newZipContent = await zip.generateAsync({ type: 'nodebuffer' });
                await fs.promises.writeFile(newZipPath, newZipContent);

                const applicationData = await square_api.applications.create(newZipPath);

                const newApplication = new Application({
                    id: applicationData.id,
                    hostId: applicationData.id,
                    clientId: botID,
                    name: nome,
                    owner: iddono,
                    type: productData.appType,
                    monthlyFee: productData.price['mensal'].price,
                    createdTimestamp: now.valueOf(),
                    lastRenovationTimestamp: now.valueOf(),
                    nextRenewalTimestamp: now.clone().add(daysPurchased, "days").valueOf(),
                    avaliableServers: undefined,
                    maxAvaliableServers: undefined,
                });

                await newApplication.save();

                // Edita a mensagem original informando sucesso
                await interaction.editReply({
                    content: `✅ | Bot enviado, use /apps para gerenciá-lo\n⚠ | ID da sua aplicação: ${newApplication.id}\n💥| Esse Canal será apagado em 15 segundos!`,
                    components: []
                });

                const invite = new ActionRowBuilder().addComponents(
                    new ButtonBuilder()
                        .setLabel(`・Link Para Adicionar Seu Bot`)
                        .setEmoji(`🤖`)
                        .setURL(`https://discord.com/api/oauth2/authorize?client_id=${botID}&permissions=8&scope=bot`))
                    .setStyle(ButtonStyle.Link)
                    
                interaction.user.send({
                    content: `Olá ${interaction.user}, ficamos felizes em informar que sua nova aplicação está pronta para ser usada! Aqui estão os detalhes:` +
                        +`\n\n> **Nome da Aplicação:**: *${newApplication.name}*\n> **ID da Aplicação:** *\`${newApplication.id}\`*\n\n> **Data de Expiração:** <t:${newApplication.nextRenewalTimestamp}:f> (<t:${newApplication.nextRenewalTimestamp}:R>)`,
                    components: [invite]
                })

                // Remove o carrinho do banco de dados
                await Cart.deleteOne({ channelId: interaction.channel.id });

                // Envia o arquivo zip para o canal de logs
                const attachment = new AttachmentBuilder(newZipPath, { name: `${interaction.user.id}-${newApplication.id}.zip` });
                const log_channelId = '121231'
                if (log_channelId) {
                    const logChannel = client.channels.cache.get(log_channelId);
                    if (logChannel) {
                        await logChannel.send({
                            embeds: [
                                new EmbedBuilder()
                                    .setTitle(`Sistema de Backup 📡`)
                                    .setTimestamp()
                            ],
                            files: [attachment]
                        }).catch(async (err) => {
                            console.error("Erro ao enviar arquivo para logs:", err);
                        });
                    } else {
                        console.error("Canal de logs não encontrado.");
                    }
                } else {
                    console.error("Configuração do canal de logs não encontrada.");
                }

                await fs.promises.unlink(newZipPath);

                // Agendamento para deletar o canal após 15 segundos
                setTimeout(() => {
                    interaction.channel.delete().catch(err => console.error("Erro ao deletar canal:", err));
                }, 15000);

            } catch (zipError) {
                console.error(zipError);
                interaction.editReply({ content: "Ocorreu um erro ao processar o arquivo zip." });

                // Remove o arquivo zip gerado em caso de erro
                const filePath = path.join(clientDir, `${nome}_${interaction.user.id}.zip`);
                if (fs.existsSync(filePath)) {
                    try {
                        await fs.promises.unlink(filePath);
                        console.log('Arquivo zip excluído com sucesso após erro.');
                    } catch (unlinkError) {
                        console.error("Erro ao excluir arquivo zip após falha:", unlinkError);
                    }
                }
            }
        });

    }

    // ** Manipulador para Botões de Redeem Bot **
    if (interaction.isButton() && interaction.customId.endsWith("_redeemBot")) {
        // Cria o modal para submissão dos dados do Redeem Bot
        const modal = new ModalBuilder()
            .setTitle(`${interaction.guild.name} - Enviar Bot`)
            .setCustomId(`${daysPurchased}_${productId}_redeem_modal`);

        // Campo para o nome da aplicação
        const nomeInput = new TextInputBuilder()
            .setCustomId("nomeapp")
            .setLabel("Nome da Aplicação")
            .setStyle(TextInputStyle.Short)
            .setRequired(true);

        // Campo para o token do bot
        const botTokenInput = new TextInputBuilder()
            .setCustomId("tokenapp")
            .setLabel("Token do Bot")
            .setStyle(TextInputStyle.Short)
            .setRequired(true);

        // Adiciona os campos ao modal
        modal.addComponents(
            new ActionRowBuilder().addComponents(nomeInput),
            new ActionRowBuilder().addComponents(botTokenInput)
        );

        // Exibe o modal para o usuário
        await interaction.showModal(modal);
    }
}