vkdeploy-cli 0.0.8

package/README.md

@@ -0,0 +1,191 @@
+# vkdeploy-cli
+
+CLI em Node.js para gerar o bundle de um app React Native, compactar os assets e enviar o arquivo para o backend de versionamento.
+
+## O que esse projeto faz
+
+O `vkdeploy` automatiza o fluxo de publicação de bundle:
+
+1. abre o fluxo de login para o usuário obter um token;
+2. salva o token localmente;
+3. gera o bundle React Native Android;
+4. compacta bundle + assets em um `.zip`;
+5. lê a configuração do projeto React Native;
+6. envia o arquivo para a API de versionamento.
+
+## Requisitos
+
+- Node.js `>=18`
+- `zip` instalado no sistema
+- projeto React Native com pasta `android/`
+- arquivo `android/app/src/main/assets/vkdeploy-config.json`
+
+Exemplo mínimo do arquivo de configuração:
+
+```json
+{
+  "app_secret": "SEU_APP_SECRET"
+}
+```
+
+## Instalação
+
+### Desenvolvimento local com link
+
+Dentro deste projeto:
+
+```bash
+npm install
+npm link
+```
+
+Depois disso, o comando global `vkdeploy` passa a apontar para o código local. Qualquer alteração no código já entra na próxima execução.
+
+### Instalação global
+
+```bash
+npm install -g .
+```
+
+## Configuração de ambiente
+
+O projeto lê variáveis de ambiente de:
+
+- `process.env`
+- arquivo local `.env`
+- fallback definido no código
+
+Arquivo de exemplo: [.env.example](/home/vinikir/Projetos/Versionamento/vkdeploy-cli/.env.example:1)
+
+Variáveis disponíveis:
+
+- `FRONTEND_BASE_URL`: base usada para abrir a página de login
+- `API_BASE_URL`: base usada para enviar o bundle para o backend
+
+Exemplo:
+
+```env
+FRONTEND_BASE_URL=http://localhost:3000
+API_BASE_URL=http://localhost:3300
+```
+
+## Comandos
+
+### `vkdeploy login`
+
+Abre a URL de login no navegador e pede o token no terminal.
+
+Fluxo atual:
+
+1. abre a URL montada a partir de `FRONTEND_BASE_URL`;
+2. solicita `Insira o token gerado:`;
+3. salva o token em `database/loginStatus.json`.
+
+### `vkdeploy release-react <projeto> <os>`
+
+Executa o fluxo de geração e upload do bundle.
+
+Exemplo:
+
+```bash
+vkdeploy release-react "Teste REAL" android
+```
+
+Fluxo atual:
+
+1. verifica se existe login salvo;
+2. gera o bundle em `./temp/vkdeploy`;
+3. compacta os arquivos em `bundle-assets.zip`;
+4. lê `app_secret` de `android/app/src/main/assets/vkdeploy-config.json`;
+5. lê `versionName` de `android/app/build.gradle`;
+6. envia o zip para backend;
+7. remove arquivos temporários.
+
+## Scripts de qualidade
+
+```bash
+npm run lint
+npm run lint:fix
+npm run format
+npm run format:check
+```
+
+## Estrutura do projeto
+
+```txt
+bin/
+  cli.js
+  bundle.js
+src/
+  Login.js
+  config/
+    env.js
+database/
+  loginStatus.json
+```
+
+## Funções principais
+
+Responsável por montar os comandos do CLI com `yargs`.
+
+Funções:
+
+- `ensureDatabaseDirExists()`: cria o diretório de persistência do login, se ele não existir
+- `isLoggedIn()`: verifica se existe status de login salvo no JSON
+
+Comandos:
+
+- `login`: abre o fluxo de autenticação e persiste o token
+- `release-react`: dispara a geração e o upload do bundle
+
+Responsável pela parte operacional do release.
+
+Funções:
+
+- `deleteFolderRecursive(folderPath)`: remove diretórios e arquivos recursivamente
+- `buscProjetoId()`: lê o `app_secret` do arquivo `vkdeploy-config.json`
+- `generateBundle()`: executa o comando `react-native bundle`
+- `pegaVersionName()`: extrai o `versionName` do `build.gradle`
+- `CompactarArquivos()`: gera o `bundle-assets.zip`
+- `UploadBundle()`: envia o zip para a API
+- `hashFileSha256(filePath)`: calcula o hash SHA-256 do arquivo gerado
+- `toMb(bytes)`: converte bytes para MB para exibição no terminal
+
+Responsável por centralizar a configuração de URLs.
+
+Funções internas:
+
+- `parseEnvFile(fileContent)`: interpreta o conteúdo do `.env`
+- `getEnvValue(key, fallback)`: lê da variável de ambiente, do `.env` local ou do fallback
+- `normalizeBaseUrl(value)`: remove `/` no fim da base URL
+- `buildUrl(baseUrl, pathname)`: monta a URL final
+
+Valores exportados:
+
+- `FRONTEND_BASE_URL`
+- `API_BASE_URL`
+- `LOGIN_URL`
+- `UPLOAD_BUNDLE_URL`
+
+Responsável por abrir no navegador a URL de login calculada em `env.js`.
+
+Função:
+
+- `login()`: abre `LOGIN_URL`
+
+## Tratamento de erro implementado
+
+Hoje o CLI já valida alguns pontos antes do upload:
+
+- ausência de `vkdeploy-config.json`
+- JSON inválido em `vkdeploy-config.json`
+- ausência de `app_secret`
+- ausência de `bundle-assets.zip`
+- ausência de `versionName` no `build.gradle`
+
+## Limitações atuais
+
+- o token ainda é salvo dentro do projeto, em `database/loginStatus.json`
+- o fluxo de upload ainda não envia o token salvo para a API
+- o código hoje está preparado principalmente para Android
+- há pontos de refatoração pendentes no fluxo assíncrono de `bundle.js`

package/bin/bundle.js

@@ -0,0 +1,260 @@
+import chalk from "chalk";
+import axios from "axios";
+import FormData from "form-data";
+import { exec } from "child_process";
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { UPLOAD_BUNDLE_URL } from "../src/config/env.js";
+
+const tmpDir = path.resolve("./temp");
+const versionamentoClubeDir = path.resolve(tmpDir, "vkdeploy");
+let jaExistiaPastaTemp = false;
+
+const toMb = (bytes) => (bytes / (1024 * 1024)).toFixed(2);
+
+const hashFileSha256 = (filePath) =>
+  new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+
+export const deleteFolderRecursive = (folderPath) => {
+  if (fs.existsSync(folderPath)) {
+    fs.readdirSync(folderPath).forEach((file) => {
+      const curPath = path.join(folderPath, file);
+
+      if (fs.lstatSync(curPath).isDirectory()) {
+        deleteFolderRecursive(curPath);
+      } else {
+        fs.unlinkSync(curPath);
+      }
+    });
+
+    fs.rmdirSync(folderPath);
+  }
+};
+
+export const buscProjetoId = async () => {
+  const configFilePath = path.resolve(
+    "./android/app/src/main/assets/vkdeploy-config.json"
+  );
+
+  if (!fs.existsSync(configFilePath)) {
+    throw new Error(
+      [
+        "Arquivo de configuração não encontrado.",
+        `Crie o arquivo em: ${configFilePath}`,
+        'Conteúdo mínimo esperado: {"app_secret":"SEU_APP_SECRET"}',
+      ].join("\n")
+    );
+  }
+
+  const fileContent = fs.readFileSync(configFilePath, "utf8");
+  let jsonData;
+
+  try {
+    jsonData = JSON.parse(fileContent);
+  } catch (error) {
+    throw new Error(
+      `Arquivo de configuração inválido em ${configFilePath}: JSON mal formatado.`
+    );
+  }
+
+  if (
+    typeof jsonData.app_secret !== "string" ||
+    jsonData.app_secret.trim() === ""
+  ) {
+    throw new Error(`O campo "app_secret" é obrigatório em ${configFilePath}.`);
+  }
+
+  return jsonData.app_secret.trim();
+};
+
+export const generateBundle = async () => {
+  try {
+    console.log(chalk.blue(`📦 Gerando o bundle ...`), "\n");
+    //const command = `npx react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res`;
+    const command = `npx react-native bundle --platform android --dev false --entry-file index.js --bundle-output ./temp/vkdeploy/index.android.bundle --assets-dest ./temp/vkdeploy`;
+    //const command = `npx react-native bundle --platform android --dev false --entry-file index.js --bundle-output ./temp/vkdeploy/index.android.bundle --assets-dest ./temp/vkdeploy/assets`
+    //const command = `ls`;
+
+    if (!fs.existsSync(tmpDir)) {
+      fs.mkdirSync(tmpDir, { recursive: true });
+    } else {
+      jaExistiaPastaTemp = true;
+    }
+
+    if (!fs.existsSync(versionamentoClubeDir)) {
+      fs.mkdirSync(versionamentoClubeDir, { recursive: true });
+    }
+
+    exec(command, (error, stdout, stderr) => {
+      if (
+        error &&
+        error.message !=
+          `warn Package react-native-sqlite-storage contains invalid configuration: "dependency.platforms.ios.project" is not allowed. Please verify it's properly linked using "npx react-native config" command and contact the package maintainers about this.`
+      ) {
+        console.log(
+          chalk.red(`❌ Erro: Falha ao gerar o bundle: ${error.message}`)
+        );
+        return false;
+      }
+
+      if (stderr) {
+        console.log(chalk.yellow(`💡  Aviso: ${stderr}`));
+      }
+
+      console.log(chalk.green("✅ O bundle foi gerado com sucesso!"), "\n");
+      CompactarArquivos();
+    });
+  } catch (e) {
+    deleteFolderRecursive(versionamentoClubeDir);
+    if (!jaExistiaPastaTemp) {
+      deleteFolderRecursive("temp");
+    }
+    console.log(
+      chalk.red(`❌ Erro: Falha ao gerar o bundle: ${e.message}`),
+      "\n"
+    );
+  }
+};
+const pegaVersionName = () => {
+  try {
+    const gradleFilePath = "./android/app/build.gradle";
+
+    const gradleFileContent = fs.readFileSync(gradleFilePath, "utf-8");
+
+    const versionNameMatch = gradleFileContent.match(/versionName\s+"([^"]+)"/);
+
+    if (versionNameMatch && versionNameMatch[1]) {
+      const versionName = versionNameMatch[1];
+
+      return versionName;
+    }
+
+    throw new Error("Atributo versionName não encontrado no arquivo.");
+  } catch (e) {
+    throw new Error(e.message);
+  }
+};
+
+const CompactarArquivos = async () => {
+  try {
+    //index.android.bundle
+    //const command2 = `tar -czvf bundle-assets.tar -C android/app/src/main assets/index.android.bundle res`;
+    //const command2 = `cd android/app/src/main && zip -r ../../../../bundle-assets.zip assets/index.android.bundle res && cd ../../../../`;
+    //const command2 = `zip -r bundle-assets.zip  temp/vkdeploy/*`;
+    const command2 = `cd temp/vkdeploy && zip -r ../../bundle-assets.zip * && cd ../../`;
+
+    console.log(chalk.blue(`🗃️  Empacotando o bundle e os assets ...`), "\n");
+
+    exec(command2, (error, stdout, stderr) => {
+      if (error) {
+        console.log(
+          chalk.red(
+            `❌ Erro: Falha ao gerar o empacotamento do bundle e assets : ${error.message}`
+          )
+        );
+        return false;
+      }
+
+      if (stderr) {
+        console.log(chalk.yellow(`💡  Aviso: ${stderr}`));
+      }
+
+      console.log(
+        chalk.green("✅ O bundle e os assets foram empacotados com sucesso!"),
+        "\n"
+      );
+
+      deleteFolderRecursive(versionamentoClubeDir);
+      if (!jaExistiaPastaTemp) {
+        deleteFolderRecursive("temp");
+      }
+      UploadBundle();
+    });
+    // UploadBundle();
+  } catch (e) {
+    deleteFolderRecursive(versionamentoClubeDir);
+    if (!jaExistiaPastaTemp) {
+      deleteFolderRecursive("temp");
+    }
+    deleteFolderRecursive("bundle-assets.zip");
+    throw new Error(e.message);
+  }
+};
+
+const UploadBundle = async () => {
+  try {
+    console.log(chalk.blue(`📤 Upload do bundle...`), "\n");
+
+    const projectId = await buscProjetoId();
+    //const filePath = "./android/app/src/main/assets/index.android.bundle"
+    const filePath = "./bundle-assets.zip";
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Arquivo de upload não encontrado: ${filePath}`);
+    }
+
+    const zipStats = fs.statSync(filePath);
+    const zipHash = await hashFileSha256(filePath);
+    const zipAbsolutePath = path.resolve(filePath);
+
+    console.log(chalk.blue("🧾 Validando arquivo de upload..."), "\n");
+    console.log(`Arquivo: ${path.basename(filePath)}`);
+    console.log(`Caminho: ${zipAbsolutePath}`);
+    console.log(`Tamanho: ${zipStats.size} bytes (${toMb(zipStats.size)} MB)`);
+    console.log(`SHA256: ${zipHash}`, "\n");
+
+    const uploadUrl = UPLOAD_BUNDLE_URL;
+
+    const fileStream = fs.createReadStream(filePath);
+
+    const versionBundle = pegaVersionName();
+
+    const formData = new FormData();
+
+    formData.append("projeto", projectId);
+    formData.append("versaoBuild", versionBundle);
+
+    formData.append("file", fileStream);
+    let versaoUltima;
+
+    await axios
+      .post(uploadUrl, formData, {
+        headers: {
+          ...formData.getHeaders(),
+        },
+      })
+      .then((res) => {
+        versaoUltima = res.data.versao;
+      })
+      .catch((e) => {
+        console.log("Errroooo", JSON.stringify(e));
+        fs.unlinkSync(filePath);
+        throw new Error(e.message);
+      });
+
+    console.log(chalk.green("✅ O upload foi realizado com sucesso!"), "\n");
+    console.log(
+      chalk.green(
+        `Versão publicada: Android ${versionBundle}, bundle ${versaoUltima} (V ${versionBundle}.${versaoUltima})`
+      ),
+      "\n"
+    );
+
+    fs.unlinkSync(filePath);
+  } catch (error) {
+    console.log(
+      chalk.red(`❌ Erro: Falha ao fazer upload do bundle: ${error.message}`),
+      "\n"
+    );
+  } finally {
+    deleteFolderRecursive("bundle-assets.zip");
+  }
+};

package/bin/cli.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+import { generateBundle } from "./bundle.js";
+import fs from "fs";
+import path from "path";
+import login from "../src/Login.js";
+import readline from "readline";
+
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Ajuste o caminho para salvar o arquivo na pasta 'database' uma pasta atrás
+const loginFilePath = path.resolve(__dirname, "../database/loginStatus.json");
+
+const ensureDatabaseDirExists = () => {
+  const dir = path.dirname(loginFilePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+};
+// async function login() {
+//     // Função para fazer o login
+//     console.log("Realizando login...");
+//     // Adicione aqui a lógica de login
+
+//     // Simulando login bem-sucedido
+//     const loginStatus = { loggedIn: true };
+//     fs.writeFileSync(loginFilePath, JSON.stringify(loginStatus));
+//     console.log("Login realizado com sucesso.");
+// }
+
+function isLoggedIn() {
+  if (fs.existsSync(loginFilePath)) {
+    const loginStatus = JSON.parse(fs.readFileSync(loginFilePath, "utf-8"));
+    return loginStatus.loggedIn;
+  }
+  return false;
+}
+
+yargs(hideBin(process.argv))
+  .command(
+    "release-react [projeto]",
+    "Gera bundle e faz upload",
+    (yargs) => {
+      return yargs
+        .positional("projeto", {
+          describe: "Projeto alvo",
+          default: "meu-projeto",
+        })
+        .positional("os", {
+          describe: "OS alvo",
+          default: "android",
+        });
+    },
+    async (argv) => {
+      console.log(isLoggedIn());
+      if (!isLoggedIn()) {
+        console.log("Você precisa estar logado para gerar o bundle.");
+        return;
+      }
+
+      if (argv.os == "android") {
+        console.log(`Gerando bundle para ${argv.projeto} os ${argv.os} `, "\n");
+        await generateBundle();
+      }
+
+      if (argv.os == "ios") {
+        console.log(`Gerando bundle para ${argv.projeto} os ${argv.os} `, "\n");
+        //await generateBundleIOS()
+      }
+    }
+  )
+  .command(
+    "login",
+    "Realiza login",
+    (yargs) => {
+      return yargs;
+    },
+    async () => {
+      login();
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      rl.question("Insira o token gerado: ", (token) => {
+        // Simulando login bem-sucedido com o token
+        const loginStatus = { loggedIn: true, token: token };
+        ensureDatabaseDirExists();
+        fs.writeFileSync(loginFilePath, JSON.stringify(loginStatus));
+        console.log("Login realizado com sucesso.");
+        rl.close();
+      });
+    }
+  )
+  .help()
+  .parse();

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "vkdeploy-cli",
+  "version": "0.0.8",
+  "main": "index.js",
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "peerDependencies": {
+    "fs": "^0.0.1-security",
+    "react": "18.3.1"
+  },
+  "bin": {
+    "vkdeploy": "./bin/cli.js"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "chalk": "^5.3.0",
+    "child_process": "^1.0.2",
+    "events": "^3.3.0",
+    "form-data": "^4.0.1",
+    "open": "^10.1.0",
+    "path": "^0.12.7",
+    "readline": "^1.3.0",
+    "timers": "^0.1.1",
+    "xml2js": "^0.6.2",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.1",
+    "prettier": "^3.3.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "module"
+}

package/src/Login.js

@@ -0,0 +1,8 @@
+import open from "open";
+import { LOGIN_URL } from "./config/env.js";
+
+function login() {
+  open(LOGIN_URL);
+}
+
+export default login;

package/src/config/env.js

@@ -0,0 +1,64 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, "../..");
+const envFilePath = path.join(rootDir, ".env");
+
+const parseEnvFile = (fileContent) => {
+  const env = {};
+
+  for (const rawLine of fileContent.split(/\r?\n/)) {
+    const line = rawLine.trim();
+
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+
+    const separatorIndex = line.indexOf("=");
+
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const key = line.slice(0, separatorIndex).trim();
+    let value = line.slice(separatorIndex + 1).trim();
+
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    env[key] = value;
+  }
+
+  return env;
+};
+
+const fileEnv = fs.existsSync(envFilePath)
+  ? parseEnvFile(fs.readFileSync(envFilePath, "utf-8"))
+  : {};
+
+const getEnvValue = (key, fallback) =>
+  process.env[key] || fileEnv[key] || fallback;
+
+const normalizeBaseUrl = (value) => value.replace(/\/+$/, "");
+
+const buildUrl = (baseUrl, pathname) =>
+  `${normalizeBaseUrl(baseUrl)}${pathname}`;
+
+export const FRONTEND_BASE_URL = getEnvValue(
+  "FRONTEND_BASE_URL",
+  "http://localhost:3000"
+);
+export const API_BASE_URL = getEnvValue(
+  "API_BASE_URL",
+  "https://versionamento-back-end-388770734965.us-central1.run.app"
+);
+
+export const LOGIN_URL = buildUrl(FRONTEND_BASE_URL, "/token");
+export const UPLOAD_BUNDLE_URL = buildUrl(API_BASE_URL, "/bundle/uploadFile");