fabroku 0.1.0

package/README.md

@@ -0,0 +1,100 @@
+# 🚀 Fabroku CLI
+
+Ferramenta de linha de comando para o [Fabroku PaaS](https://github.com/fabricadesoftware-ifc/Fabroku) — verifica arquivos de deploy, autentica via GitHub e gerencia apps.
+
+## Instalação
+
+```bash
+npm i -g fabroku
+```
+
+> Requer Node.js 18+
+
+## Comandos
+
+### `fabroku verify`
+
+Verifica se o projeto tem os arquivos necessários para deploy no Dokku.
+
+```bash
+# No diretório do projeto
+fabroku verify
+
+# Especificando diretório
+fabroku verify --dir ./meu-projeto
+
+# Forçar tipo (frontend ou backend)
+fabroku verify --type backend
+
+# Gerar arquivos faltantes
+fabroku verify --fix
+```
+
+**Frontend** (Vue, React, etc.) precisa de:
+- `.buildpacks`
+- `.static`
+- `static.json`
+
+**Backend** (Django, Flask, etc.) precisa de:
+- `Procfile`
+- `requirements.txt`
+- `runtime.txt`
+
+### `fabroku login`
+
+Autenticação via GitHub OAuth — abre o navegador automaticamente.
+
+```bash
+fabroku login
+
+# Apontar para API de produção
+fabroku login --api-url https://api.fabroku.ifc.edu.br
+```
+
+### `fabroku logout`
+
+Encerrar sessão.
+
+```bash
+fabroku logout
+```
+
+### `fabroku whoami`
+
+Verificar usuário autenticado e status do token.
+
+```bash
+fabroku whoami
+```
+
+### `fabroku apps`
+
+Listar seus apps.
+
+```bash
+fabroku apps
+
+# Filtrar por projeto
+fabroku apps --project 42
+```
+
+## Configuração
+
+A CLI salva as credenciais em `~/.fabroku/config.json`:
+
+```json
+{
+  "api_url": "http://localhost:8000",
+  "token": "...",
+  "user": "seu-usuario"
+}
+```
+
+## Desenvolvimento
+
+```bash
+cd Fabroku_CLI
+npm install
+npm link        # Instala globalmente em modo dev
+fabroku --help  # Testa
+```

package/bin/fabroku.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+/**
+ * 🚀 Fabroku CLI — Ferramenta de deploy para o Fabroku
+ *
+ * Instalação:  npm i -g fabroku
+ * Uso:         fabroku <comando> [opções]
+ */
+
+import { Command } from "commander";
+
+import { login, logout } from "../lib/commands/login.js";
+import { verify } from "../lib/commands/verify.js";
+import { apps } from "../lib/commands/apps.js";
+import { whoami } from "../lib/commands/whoami.js";
+
+const program = new Command();
+
+program
+  .name("fabroku")
+  .description("🚀 Fabroku CLI — Ferramenta de deploy para o Fabroku PaaS")
+  .version("0.1.0");
+
+// ---- login ----
+program
+  .command("login")
+  .description("Autenticar na plataforma Fabroku via GitHub")
+  .option("--api-url <url>", "URL base da API Fabroku")
+  .action(async (options) => {
+    await login({ apiUrl: options.apiUrl });
+  });
+
+// ---- logout ----
+program
+  .command("logout")
+  .description("Encerrar a sessão da CLI")
+  .action(() => logout());
+
+// ---- verify ----
+program
+  .command("verify")
+  .description("Verificar se o projeto tem os arquivos necessários para deploy")
+  .option("-d, --dir <path>", "Diretório do projeto", ".")
+  .option("-t, --type <type>", "Tipo da aplicação (frontend ou backend)")
+  .option("--fix", "Gerar arquivos faltantes automaticamente")
+  .action((options) => {
+    const code = verify(options);
+    if (code) process.exit(code);
+  });
+
+// ---- apps ----
+program
+  .command("apps")
+  .description("Listar seus apps na plataforma Fabroku")
+  .option("-p, --project <id>", "Filtrar por ID do projeto")
+  .action(async (options) => {
+    await apps(options);
+  });
+
+// ---- whoami ----
+program
+  .command("whoami")
+  .description("Verificar o usuário autenticado")
+  .action(async () => {
+    await whoami();
+  });
+
+program.parse();

package/lib/api.js

@@ -0,0 +1,70 @@
+/**
+ * Cliente HTTP para a API Fabroku.
+ */
+
+import { getApiUrl, getToken } from "./config.js";
+
+export class APIError extends Error {
+  constructor(statusCode, detail) {
+    super(`[${statusCode}] ${detail}`);
+    this.statusCode = statusCode;
+    this.detail = detail;
+  }
+}
+
+export class FabrokuAPI {
+  constructor() {
+    this.baseUrl = getApiUrl();
+    this.token = getToken();
+  }
+
+  get headers() {
+    const h = { Accept: "application/json" };
+    if (this.token) h.Authorization = `CLI ${this.token}`;
+    return h;
+  }
+
+  async request(method, path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const resp = await fetch(url, {
+      method,
+      headers: { ...this.headers, ...options.headers },
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!resp.ok) {
+      let detail;
+      try {
+        const data = await resp.json();
+        detail = data.detail || JSON.stringify(data);
+      } catch {
+        detail = await resp.text();
+      }
+      throw new APIError(resp.status, detail);
+    }
+    return resp.json();
+  }
+
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, { body });
+  }
+
+  // --- Endpoints ---
+
+  async checkAuth() {
+    return this.get("/api/auth/check/");
+  }
+  async listApps() {
+    return this.get("/api/apps/apps/");
+  }
+  async listProjects() {
+    return this.get("/api/projects/projects/");
+  }
+  async getUserMe() {
+    return this.get("/api/auth/users/me/");
+  }
+}

package/lib/commands/apps.js

@@ -0,0 +1,87 @@
+/**
+ * Comando `fabroku apps` — Listar apps do usuário.
+ */
+
+import chalk from "chalk";
+
+import { FabrokuAPI, APIError } from "../api.js";
+import { isAuthenticated } from "../config.js";
+
+const STATUS_COLORS = {
+  RUNNING: "green",
+  STOPPED: "red",
+  ERROR: "red",
+  STARTING: "yellow",
+  DEPLOYING: "cyan",
+  DELETING: "magenta",
+  STOPPING: "yellow",
+  RESTARTING: "blue",
+};
+
+export async function apps(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red("❌ Você precisa fazer login primeiro."));
+    console.log(`   Use: ${chalk.bold("fabroku login")}`);
+    process.exit(1);
+  }
+
+  const api = new FabrokuAPI();
+
+  let appList;
+  try {
+    const data = await api.listApps();
+    appList = data.results || [];
+  } catch (e) {
+    if (e instanceof APIError && e.statusCode === 401) {
+      console.log(
+        chalk.red("❌ Token expirado ou inválido. Faça login novamente."),
+      );
+      console.log(`   Use: ${chalk.bold("fabroku login")}`);
+    } else {
+      console.log(chalk.red(`❌ Erro na API: ${e.message}`));
+    }
+    process.exit(1);
+  }
+
+  // Filtra por projeto
+  if (options.project) {
+    appList = appList.filter(
+      (a) => String(a.project) === String(options.project),
+    );
+  }
+
+  if (appList.length === 0) {
+    console.log("\nNenhum app encontrado.");
+    if (options.project)
+      console.log(`   (filtrado por projeto: ${options.project})`);
+    return;
+  }
+
+  // Header
+  console.log();
+  console.log(
+    chalk.dim("ID".padEnd(6)) +
+      chalk.dim("Nome".padEnd(25)) +
+      chalk.dim("Status".padEnd(14)) +
+      chalk.dim("Domínio".padEnd(30)) +
+      chalk.dim("Projeto"),
+  );
+  console.log(chalk.dim("─".repeat(85)));
+
+  // Rows
+  for (const app of appList) {
+    const status = app.status || "STOPPED";
+    const color = STATUS_COLORS[status] || "white";
+    const statusText = status.charAt(0) + status.slice(1).toLowerCase();
+
+    console.log(
+      String(app.id || "").padEnd(6) +
+        (app.name || "").padEnd(25) +
+        chalk[color](statusText.padEnd(14)) +
+        (app.domain || "-").padEnd(30) +
+        String(app.project || ""),
+    );
+  }
+
+  console.log(`\n📦 Total: ${appList.length} app(s)\n`);
+}

package/lib/commands/login.js

@@ -0,0 +1,152 @@
+/**
+ * Comando `fabroku login` — Autenticação via GitHub OAuth.
+ *
+ * Abre o browser, recebe o token via servidor HTTP local.
+ */
+
+import { createServer } from "node:http";
+import { URL } from "node:url";
+import chalk from "chalk";
+import open from "open";
+
+import {
+  clearCredentials,
+  getApiUrl,
+  isAuthenticated,
+  setCredentials,
+} from "../config.js";
+
+function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+
+function htmlPage(title, body) {
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${title}</title>
+<style>
+  body{font-family:system-ui,sans-serif;display:flex;justify-content:center;
+  align-items:center;min-height:100vh;margin:0;background:#1a1a2e;color:#eee}
+  div{text-align:center;padding:2rem}
+  h1{margin-bottom:1rem}
+</style></head>
+<body><div>${body}</div></body></html>`;
+}
+
+export async function login(options) {
+  if (isAuthenticated()) {
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(
+        "Você já está autenticado. Deseja fazer login novamente? (s/N) ",
+        resolve,
+      );
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "s") return;
+  }
+
+  const baseUrl = options.apiUrl || getApiUrl();
+  const port = await findFreePort();
+  const loginUrl = `${baseUrl}/api/auth/cli/login/?port=${port}`;
+
+  console.log(`\n🔐 Abrindo browser para autenticação...`);
+  console.log(`   URL: ${chalk.dim(loginUrl)}`);
+  console.log(`   Aguardando callback na porta ${port}...\n`);
+
+  // Abre o browser
+  await open(loginUrl);
+
+  // Servidor local que espera o callback
+  return new Promise((resolve) => {
+    const connections = new Set();
+
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const user = url.searchParams.get("user");
+        const error = url.searchParams.get("error");
+        const message = url.searchParams.get("message");
+
+        if (token) {
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(
+            htmlPage(
+              "Fabroku CLI — Autenticado",
+              "<h1>✅ Login realizado com sucesso!</h1><p>Pode fechar esta janela e voltar para o terminal.</p>",
+            ),
+          );
+
+          setCredentials(token, user || "unknown", baseUrl);
+          console.log(`✅ Autenticado como ${chalk.green.bold(user)}`);
+          console.log(`   Token salvo em ~/.fabroku/config.json\n`);
+
+          shutdown();
+          resolve();
+        } else {
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(
+            htmlPage(
+              "Fabroku CLI — Erro",
+              `<h1>❌ Erro na autenticação</h1><p>${message || error || "Erro desconhecido"}</p>`,
+            ),
+          );
+
+          console.log(
+            chalk.red(`❌ Erro: ${error}: ${message || "Erro desconhecido"}`),
+          );
+
+          shutdown();
+          resolve();
+        }
+      } else {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(htmlPage("Fabroku CLI", "<p>Aguardando callback...</p>"));
+      }
+    });
+
+    // Rastreia conexões para poder destruí-las ao encerrar
+    server.on("connection", (socket) => {
+      connections.add(socket);
+      socket.on("close", () => connections.delete(socket));
+    });
+
+    function shutdown() {
+      clearTimeout(timer);
+      server.close();
+      for (const socket of connections) socket.destroy();
+    }
+
+    server.listen(port);
+
+    // Timeout de 2 minutos
+    const timer = setTimeout(() => {
+      console.log(
+        chalk.red("❌ Timeout: autenticação não foi concluída em 2 minutos."),
+      );
+      shutdown();
+      resolve();
+    }, 120_000);
+  });
+}
+
+export function logout() {
+  if (!isAuthenticated()) {
+    console.log("Você não está autenticado.");
+    return;
+  }
+  clearCredentials();
+  console.log("👋 Sessão encerrada com sucesso.");
+}

package/lib/commands/verify.js

@@ -0,0 +1,175 @@
+/**
+ * Comando `fabroku verify` — Verifica arquivos necessários para deploy.
+ *
+ * Lógica:
+ *   - Não-fábrica → detecta tipo (frontend/backend) → verifica arquivos
+ *   - Fábrica → pode usar config personalizada
+ *
+ * Frontend: .buildpacks, .static, static.json
+ * Backend:  Procfile, requirements.txt, runtime.txt
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve as pathResolve } from "node:path";
+import chalk from "chalk";
+
+const FRONTEND_FILES = {
+  ".buildpacks": {
+    description: "Lista de buildpacks para deploy estático",
+    content:
+      "https://github.com/heroku/heroku-buildpack-nodejs\nhttps://github.com/dokku/buildpack-nginx\n",
+  },
+  ".static": {
+    description: "Marcador para build estática",
+    content: "",
+  },
+  "static.json": {
+    description: "Configuração do servidor estático (rotas SPA)",
+    content:
+      JSON.stringify(
+        {
+          root: "dist/",
+          clean_urls: true,
+          routes: { "/**": "index.html" },
+          headers: {
+            "/**": { "Cache-Control": "public, max-age=0, must-revalidate" },
+            "/assets/**": {
+              "Cache-Control": "public, max-age=31536000, immutable",
+            },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+  },
+};
+
+const BACKEND_FILES = {
+  Procfile: {
+    description: "Define o comando de execução do servidor",
+    content: "web: gunicorn config.wsgi --bind 0.0.0.0:$PORT\n",
+  },
+  "requirements.txt": {
+    description: "Dependências Python do projeto",
+    content: null, // Não gera automaticamente
+  },
+  "runtime.txt": {
+    description: "Versão do Python para deploy",
+    content: "python-3.13.2\n",
+  },
+};
+
+/**
+ * Detecta o tipo de aplicação pelo diretório.
+ */
+function detectType(dir) {
+  // Frontend: tem package.json
+  if (existsSync(join(dir, "package.json"))) {
+    // Verifica se não é um backend Node (tem Procfile com "node")
+    const procfilePath = join(dir, "Procfile");
+    if (existsSync(procfilePath)) {
+      const content = readFileSync(procfilePath, "utf-8");
+      if (content.includes("node") || content.includes("npm")) {
+        return "backend";
+      }
+    }
+    return "frontend";
+  }
+
+  // Backend Python: manage.py ou requirements.txt ou setup.py ou pyproject.toml
+  const backendMarkers = [
+    "manage.py",
+    "requirements.txt",
+    "setup.py",
+    "pyproject.toml",
+    "Pipfile",
+  ];
+  if (backendMarkers.some((f) => existsSync(join(dir, f)))) {
+    return "backend";
+  }
+
+  return null;
+}
+
+export function verify(options) {
+  const dir = pathResolve(options.dir || ".");
+  const forceType = options.type || null;
+  const fix = options.fix || false;
+
+  console.log(`\n📂 Verificando: ${chalk.bold(dir)}\n`);
+
+  // Detecta ou usa tipo forçado
+  let type = forceType;
+  if (!type) {
+    type = detectType(dir);
+    if (!type) {
+      console.log(
+        chalk.yellow("⚠️  Não foi possível detectar o tipo da aplicação."),
+      );
+      console.log(
+        `   Use ${chalk.bold("--type frontend")} ou ${chalk.bold("--type backend")}\n`,
+      );
+      process.exit(1);
+    }
+  }
+
+  const typeName = type === "frontend" ? "FrontEnd" : "BackEnd";
+  const typeDesc =
+    type === "frontend"
+      ? "Aplicação SPA/estática (Vue, React, etc.)"
+      : "Aplicação Python (Django, Flask, etc.)";
+
+  console.log(`🔍 Tipo detectado: ${chalk.cyan.bold(typeName)}`);
+  console.log(`   ${typeDesc}\n`);
+
+  const requiredFiles = type === "frontend" ? FRONTEND_FILES : BACKEND_FILES;
+  let missing = 0;
+  let fixed = 0;
+
+  for (const [filename, info] of Object.entries(requiredFiles)) {
+    const filePath = join(dir, filename);
+    const exists = existsSync(filePath);
+
+    if (exists) {
+      console.log(`  ${chalk.green("✅")} ${filename}`);
+    } else {
+      console.log(
+        `  ${chalk.red("❌")} ${filename} — ${chalk.dim("faltando")}`,
+      );
+      missing++;
+
+      if (fix && info.content !== null) {
+        writeFileSync(filePath, info.content);
+        console.log(`     ${chalk.yellow("→")} Gerado com conteúdo padrão`);
+        fixed++;
+      }
+    }
+  }
+
+  console.log();
+
+  if (missing === 0) {
+    console.log(chalk.green("🚀 Projeto pronto para deploy!\n"));
+  } else if (fix && fixed > 0) {
+    const remaining = missing - fixed;
+    console.log(chalk.yellow(`🔧 ${fixed} arquivo(s) gerado(s).`));
+    if (remaining > 0) {
+      console.log(
+        chalk.red(
+          `   ${remaining} arquivo(s) precisam ser criados manualmente.`,
+        ),
+      );
+    } else {
+      console.log(chalk.green("🚀 Projeto pronto para deploy!\n"));
+    }
+  } else {
+    console.log(
+      chalk.yellow(`⚠️  ${missing} arquivo(s) faltando para deploy.`),
+    );
+    console.log(
+      `   Use ${chalk.bold("fabroku verify --fix")} para gerar automaticamente.\n`,
+    );
+  }
+
+  return missing === 0 || (fix && missing - fixed === 0) ? 0 : 1;
+}

package/lib/commands/whoami.js

@@ -0,0 +1,36 @@
+/**
+ * Comando `fabroku whoami` — Verificar usuário autenticado.
+ */
+
+import chalk from "chalk";
+
+import { FabrokuAPI, APIError } from "../api.js";
+import { isAuthenticated, loadConfig } from "../config.js";
+
+export async function whoami() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red("❌ Não autenticado."));
+    console.log(`   Use: ${chalk.bold("fabroku login")}`);
+    process.exit(1);
+  }
+
+  const config = loadConfig();
+  console.log(`\n👤 Logado como: ${chalk.green.bold(config.user || "?")}`);
+  console.log(`   API: ${chalk.dim(config.api_url)}`);
+
+  try {
+    const api = new FabrokuAPI();
+    const user = await api.getUserMe();
+
+    console.log(`   Email: ${user.email}`);
+    if (user.is_fabric) console.log("   🏭 Membro da Fábrica");
+    if (user.is_superuser) console.log("   🔑 Administrador");
+    console.log(chalk.green("   ✅ Token válido\n"));
+  } catch (e) {
+    if (e instanceof APIError && e.statusCode === 401) {
+      console.log(chalk.red("   ❌ Token expirado ou inválido\n"));
+    } else {
+      console.log(chalk.yellow(`   ⚠️  Erro ao verificar: ${e.message}\n`));
+    }
+  }
+}

package/lib/config.js

@@ -0,0 +1,64 @@
+/**
+ * Gerenciamento de configuração da CLI (~/.fabroku/config.json).
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_DIR = join(homedir(), ".fabroku");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+const DEFAULT_CONFIG = {
+  api_url: "https://fabroku-api.fabricadesoftware.ifc.edu.br",
+  token: null,
+  user: null,
+};
+
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function loadConfig() {
+  ensureDir();
+  if (!existsSync(CONFIG_FILE)) {
+    saveConfig(DEFAULT_CONFIG);
+    return { ...DEFAULT_CONFIG };
+  }
+  return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+}
+
+export function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getToken() {
+  return loadConfig().token;
+}
+
+export function getApiUrl() {
+  return loadConfig().api_url || DEFAULT_CONFIG.api_url;
+}
+
+export function setCredentials(token, user, apiUrl) {
+  const config = loadConfig();
+  config.token = token;
+  config.user = user;
+  if (apiUrl) config.api_url = apiUrl;
+  saveConfig(config);
+}
+
+export function clearCredentials() {
+  const config = loadConfig();
+  config.token = null;
+  config.user = null;
+  config.api_url = DEFAULT_CONFIG.api_url;
+  saveConfig(config);
+}
+
+export function isAuthenticated() {
+  return getToken() !== null;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "fabroku",
+  "version": "0.1.0",
+  "description": "CLI para o Fabroku PaaS — Verificação de deploy, autenticação e gerenciamento de apps.",
+  "type": "module",
+  "bin": {
+    "fabroku": "./bin/fabroku.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "keywords": [
+    "fabroku",
+    "deploy",
+    "cli",
+    "paas",
+    "dokku"
+  ],
+  "author": "Fábrica de Software IFC",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "open": "^10.1.0"
+  }
+}