agroplan-ai-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,719 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/doctor.ts
+import { existsSync as existsSync4 } from "fs";
+
+// src/utils/python.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/utils/paths.ts
+import { join, dirname } from "path";
+import { existsSync } from "fs";
+import { homedir } from "os";
+function getHomeAgroplanDir() {
+  return join(homedir(), ".agroplan");
+}
+function findProjectRoot() {
+  let currentDir = process.cwd();
+  while (currentDir !== dirname(currentDir)) {
+    const backendPath = join(currentDir, "backend");
+    const apiPath = join(backendPath, "api.py");
+    if (existsSync(backendPath) && existsSync(apiPath)) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+  throw new Error("N\xE3o foi poss\xEDvel encontrar a raiz do projeto AgroPlan AI");
+}
+function getProjectPaths() {
+  const homeDir = getHomeAgroplanDir();
+  const homeBackend = join(homeDir, "backend");
+  if (existsSync(homeBackend)) {
+    return {
+      root: homeDir,
+      backend: homeBackend,
+      api: join(homeBackend, "api.py"),
+      requirements: join(homeBackend, "requirements.txt"),
+      venv: join(homeBackend, ".venv"),
+      agroplanDir: homeDir,
+      pidFile: join(homeDir, "agroplan-api.pid"),
+      logsDir: join(homeDir, "logs"),
+      logFile: join(homeDir, "logs", "api.log")
+    };
+  }
+  try {
+    const root = findProjectRoot();
+    return {
+      root,
+      backend: join(root, "backend"),
+      api: join(root, "backend", "api.py"),
+      requirements: join(root, "backend", "requirements.txt"),
+      venv: join(root, "backend", ".venv"),
+      agroplanDir: join(root, ".agroplan"),
+      pidFile: join(root, ".agroplan", "agroplan-api.pid"),
+      logsDir: join(root, ".agroplan", "logs"),
+      logFile: join(root, ".agroplan", "logs", "api.log")
+    };
+  } catch {
+    return {
+      root: homeDir,
+      backend: homeBackend,
+      api: join(homeBackend, "api.py"),
+      requirements: join(homeBackend, "requirements.txt"),
+      venv: join(homeBackend, ".venv"),
+      agroplanDir: homeDir,
+      pidFile: join(homeDir, "agroplan-api.pid"),
+      logsDir: join(homeDir, "logs"),
+      logFile: join(homeDir, "logs", "api.log")
+    };
+  }
+}
+function ensureAgroplanDir() {
+  const paths = getProjectPaths();
+  if (!existsSync(paths.agroplanDir)) {
+    Bun.spawnSync(["mkdir", "-p", paths.agroplanDir]);
+  }
+  if (!existsSync(paths.logsDir)) {
+    Bun.spawnSync(["mkdir", "-p", paths.logsDir]);
+  }
+}
+
+// src/utils/python.ts
+function checkPython() {
+  try {
+    const result = Bun.spawnSync(["python", "--version"]);
+    if (result.success) {
+      return {
+        available: true,
+        version: result.stdout.toString().trim(),
+        path: "python"
+      };
+    }
+  } catch {}
+  try {
+    const result = Bun.spawnSync(["python3", "--version"]);
+    if (result.success) {
+      return {
+        available: true,
+        version: result.stdout.toString().trim(),
+        path: "python3"
+      };
+    }
+  } catch {}
+  return { available: false };
+}
+function checkPip() {
+  try {
+    const result = Bun.spawnSync(["pip", "--version"]);
+    if (result.success) {
+      return {
+        available: true,
+        version: result.stdout.toString().trim()
+      };
+    }
+  } catch {}
+  return { available: false };
+}
+function createVenv() {
+  const paths = getProjectPaths();
+  const python = checkPython();
+  if (!python.available || !python.path) {
+    return false;
+  }
+  try {
+    console.log("\uD83D\uDC0D Criando ambiente virtual...");
+    const result = Bun.spawnSync([python.path, "-m", "venv", ".venv"], {
+      cwd: paths.backend
+    });
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+function installRequirements() {
+  const paths = getProjectPaths();
+  if (!existsSync2(paths.venv)) {
+    console.log("\u274C Ambiente virtual n\xE3o encontrado");
+    return false;
+  }
+  try {
+    console.log("\uD83D\uDCE6 Instalando depend\xEAncias...");
+    const isWindows = process.platform === "win32";
+    const pipPath = isWindows ? `${paths.venv}/Scripts/pip.exe` : `${paths.venv}/bin/pip`;
+    const result = Bun.spawnSync([pipPath, "install", "-r", "requirements.txt"], {
+      cwd: paths.backend
+    });
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+function getVenvPython() {
+  const paths = getProjectPaths();
+  if (!existsSync2(paths.venv)) {
+    return null;
+  }
+  const isWindows = process.platform === "win32";
+  const pythonPath = isWindows ? `${paths.venv}/Scripts/python.exe` : `${paths.venv}/bin/python`;
+  return existsSync2(pythonPath) ? pythonPath : null;
+}
+
+// src/utils/process.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync, unlinkSync } from "fs";
+function savePid(pid) {
+  const paths = getProjectPaths();
+  writeFileSync(paths.pidFile, pid.toString());
+}
+function readPid() {
+  const paths = getProjectPaths();
+  if (!existsSync3(paths.pidFile)) {
+    return null;
+  }
+  try {
+    const pidStr = readFileSync(paths.pidFile, "utf-8").trim();
+    return parseInt(pidStr, 10);
+  } catch {
+    return null;
+  }
+}
+function removePidFile() {
+  const paths = getProjectPaths();
+  if (existsSync3(paths.pidFile)) {
+    unlinkSync(paths.pidFile);
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    setTimeout(() => {
+      if (isProcessRunning(pid)) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {}
+      }
+    }, 2000);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPort(port) {
+  return new Promise((resolve) => {
+    try {
+      fetch(`http://localhost:${port}/health`, {
+        signal: AbortSignal.timeout(1000)
+      }).then(() => resolve(true)).catch(() => resolve(false));
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+// src/commands/doctor.ts
+async function doctorCommand() {
+  console.log(`\uD83D\uDD0D AgroPlan AI - Diagn\xF3stico do Sistema
+`);
+  let allGood = true;
+  console.log("\uD83D\uDC0D Python:");
+  const python = checkPython();
+  if (python.available) {
+    console.log(`   \u2705 ${python.version} (${python.path})`);
+  } else {
+    console.log("   \u274C Python n\xE3o encontrado");
+    console.log("      Instale Python 3.8+ em https://python.org");
+    allGood = false;
+  }
+  console.log(`
+\uD83D\uDCE6 pip:`);
+  const pip = checkPip();
+  if (pip.available) {
+    console.log(`   \u2705 ${pip.version}`);
+  } else {
+    console.log("   \u274C pip n\xE3o encontrado");
+    allGood = false;
+  }
+  console.log(`
+\uD83D\uDCC1 Estrutura do Projeto:`);
+  try {
+    const paths = getProjectPaths();
+    if (existsSync4(paths.backend)) {
+      console.log("   \u2705 Pasta backend/ encontrada");
+    } else {
+      console.log("   \u274C Pasta backend/ n\xE3o encontrada");
+      allGood = false;
+    }
+    if (existsSync4(paths.api)) {
+      console.log("   \u2705 Arquivo api.py encontrado");
+    } else {
+      console.log("   \u274C Arquivo api.py n\xE3o encontrado");
+      allGood = false;
+    }
+    if (existsSync4(paths.requirements)) {
+      console.log("   \u2705 Arquivo requirements.txt encontrado");
+    } else {
+      console.log("   \u274C Arquivo requirements.txt n\xE3o encontrado");
+      allGood = false;
+    }
+    if (existsSync4(paths.venv)) {
+      console.log("   \u2705 Ambiente virtual (.venv) encontrado");
+    } else {
+      console.log("   \u26A0\uFE0F  Ambiente virtual n\xE3o encontrado (ser\xE1 criado automaticamente)");
+    }
+  } catch (error) {
+    console.log("   \u274C Erro ao verificar estrutura do projeto");
+    console.log(`      ${error}`);
+    allGood = false;
+  }
+  console.log(`
+\uD83C\uDF10 Conectividade:`);
+  const localRunning = await checkPort(8000);
+  if (localRunning) {
+    console.log("   \u2705 API local rodando em http://localhost:8000");
+  } else {
+    console.log("   \u26A0\uFE0F  API local n\xE3o est\xE1 rodando");
+  }
+  try {
+    const renderResponse = await fetch("https://agroplan-ai-api.onrender.com/health", {
+      signal: AbortSignal.timeout(5000)
+    });
+    if (renderResponse.ok) {
+      const data = await renderResponse.json();
+      console.log("   \u2705 API Render online");
+      console.log(`      Culturas: ${data.culturas}, Talh\xF5es: ${data.talhoes}`);
+    } else {
+      console.log("   \u26A0\uFE0F  API Render com problemas");
+    }
+  } catch {
+    console.log("   \u274C API Render n\xE3o acess\xEDvel");
+  }
+  console.log(`
+` + "=".repeat(50));
+  if (allGood) {
+    console.log("\u2705 Sistema pronto para uso!");
+    console.log(`
+Pr\xF3ximos passos:`);
+    console.log("   bun run agroplan serve on    # Iniciar API local");
+    console.log("   bun run agroplan open        # Abrir no navegador");
+  } else {
+    console.log("\u274C Alguns problemas foram encontrados");
+    console.log(`
+Correja os problemas acima e execute novamente:`);
+    console.log("   bun run agroplan doctor");
+  }
+}
+
+// src/commands/serve.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { spawn } from "child_process";
+async function serveOnCommand() {
+  console.log(`\uD83D\uDE80 Iniciando API local do AgroPlan AI...
+`);
+  const paths = getProjectPaths();
+  if (!existsSync5(paths.backend) || !existsSync5(paths.api)) {
+    console.log("\u274C API local ainda n\xE3o configurada");
+    console.log(`
+\uD83D\uDCA1 Execute primeiro:`);
+    console.log("   agroplan setup");
+    console.log(`
+   Isso criar\xE1 a instala\xE7\xE3o local em:`);
+    console.log(`   ${paths.backend}`);
+    return;
+  }
+  const existingPid = readPid();
+  if (existingPid && isProcessRunning(existingPid)) {
+    console.log("\u2705 API local j\xE1 est\xE1 rodando!");
+    console.log(`   PID: ${existingPid}`);
+    console.log("   URL: http://localhost:8000");
+    return;
+  }
+  if (existingPid) {
+    removePidFile();
+  }
+  ensureAgroplanDir();
+  if (!existsSync5(paths.venv)) {
+    console.log("\uD83D\uDC0D Criando ambiente virtual...");
+    if (!createVenv()) {
+      console.log("\u274C Falha ao criar ambiente virtual");
+      return;
+    }
+  }
+  const venvPython = getVenvPython();
+  if (!venvPython) {
+    console.log("\u274C Ambiente virtual n\xE3o encontrado");
+    return;
+  }
+  console.log("\uD83D\uDCE6 Verificando depend\xEAncias...");
+  if (!installRequirements()) {
+    console.log("\u274C Falha ao instalar depend\xEAncias");
+    return;
+  }
+  const portInUse = await checkPort(8000);
+  if (portInUse) {
+    console.log("\u274C Porta 8000 j\xE1 est\xE1 em uso");
+    console.log("   Verifique se outro processo est\xE1 usando a porta");
+    return;
+  }
+  console.log("\uD83C\uDF10 Iniciando servidor uvicorn...");
+  const isWindows = process.platform === "win32";
+  const uvicornPath = isWindows ? `${paths.venv}/Scripts/uvicorn.exe` : `${paths.venv}/bin/uvicorn`;
+  const child = spawn(uvicornPath, [
+    "api:app",
+    "--host",
+    "127.0.0.1",
+    "--port",
+    "8000",
+    "--log-level",
+    "info"
+  ], {
+    cwd: paths.backend,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      CORS_ORIGINS: "https://agroplan-ai.vercel.app,http://localhost:3000,http://127.0.0.1:3000"
+    }
+  });
+  savePid(child.pid);
+  const logStream = Bun.file(paths.logFile).writer();
+  child.stdout?.on("data", (data) => {
+    logStream.write(data);
+  });
+  child.stderr?.on("data", (data) => {
+    logStream.write(data);
+  });
+  child.unref();
+  console.log("\u23F3 Aguardando inicializa\xE7\xE3o...");
+  let attempts = 0;
+  const maxAttempts = 10;
+  while (attempts < maxAttempts) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const running = await checkPort(8000);
+    if (running) {
+      console.log("\u2705 API local iniciada com sucesso!");
+      console.log(`   PID: ${child.pid}`);
+      console.log("   URL: http://localhost:8000");
+      console.log("   Health: http://localhost:8000/health");
+      console.log(`
+\uD83D\uDCA1 Use 'bun run agroplan serve off' para parar`);
+      return;
+    }
+    attempts++;
+  }
+  console.log("\u274C Falha ao iniciar API local");
+  console.log("   Verifique os logs: bun run agroplan serve logs");
+}
+async function serveOffCommand() {
+  console.log(`\uD83D\uDED1 Parando API local...
+`);
+  const pid = readPid();
+  if (!pid) {
+    console.log("\u26A0\uFE0F  Nenhuma API local encontrada");
+    return;
+  }
+  if (!isProcessRunning(pid)) {
+    console.log("\u26A0\uFE0F  Processo n\xE3o est\xE1 rodando");
+    removePidFile();
+    return;
+  }
+  console.log(`\uD83D\uDD04 Encerrando processo ${pid}...`);
+  if (killProcess(pid)) {
+    removePidFile();
+    console.log("\u2705 API local parada com sucesso!");
+  } else {
+    console.log("\u274C Falha ao parar API local");
+    console.log("   Tente encerrar manualmente o processo");
+  }
+}
+async function serveStatusCommand() {
+  console.log(`\uD83D\uDCCA Status da API Local
+`);
+  const pid = readPid();
+  const running = pid ? isProcessRunning(pid) : false;
+  const portActive = await checkPort(8000);
+  if (running && portActive) {
+    console.log("\u2705 API Local: ONLINE");
+    console.log(`   PID: ${pid}`);
+    console.log("   URL: http://localhost:8000");
+    try {
+      const response = await fetch("http://localhost:8000/health");
+      if (response.ok) {
+        const data = await response.json();
+        console.log(`   Status: ${data.status}`);
+        console.log(`   Culturas: ${data.culturas}`);
+        console.log(`   Talh\xF5es: ${data.talhoes}`);
+        console.log(`   Cache items: ${data.cache_items}`);
+      }
+    } catch {
+      console.log("   \u26A0\uFE0F  Health check falhou");
+    }
+  } else if (pid && !running) {
+    console.log("\u274C API Local: PROCESSO MORTO");
+    console.log(`   PID antigo: ${pid} (n\xE3o est\xE1 rodando)`);
+    removePidFile();
+  } else if (!pid && portActive) {
+    console.log("\u26A0\uFE0F  API Local: PORTA OCUPADA");
+    console.log("   Porta 8000 est\xE1 em uso por outro processo");
+  } else {
+    console.log("\u2B55 API Local: OFFLINE");
+  }
+  console.log(`
+\uD83C\uDF10 API Render:`);
+  try {
+    const response = await fetch("https://agroplan-ai-api.onrender.com/health", {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      console.log("   \u2705 ONLINE");
+      console.log(`   Cache items: ${data.cache_items}`);
+    } else {
+      console.log("   \u274C OFFLINE ou com problemas");
+    }
+  } catch {
+    console.log("   \u274C INACESS\xCDVEL");
+  }
+}
+function serveLogsCommand() {
+  console.log(`\uD83D\uDCCB Logs da API Local
+`);
+  const paths = getProjectPaths();
+  if (!existsSync5(paths.logFile)) {
+    console.log("\u26A0\uFE0F  Arquivo de log n\xE3o encontrado");
+    console.log(`   Esperado em: ${paths.logFile}`);
+    return;
+  }
+  try {
+    const logs = readFileSync2(paths.logFile, "utf-8");
+    const lines = logs.split(`
+`);
+    const recentLines = lines.slice(-50).filter((line) => line.trim());
+    if (recentLines.length === 0) {
+      console.log("\uD83D\uDCC4 Log vazio");
+      return;
+    }
+    console.log("\uD83D\uDCC4 \xDAltimas linhas do log:");
+    console.log("-".repeat(60));
+    recentLines.forEach((line) => console.log(line));
+    console.log("-".repeat(60));
+    console.log(`
+\uD83D\uDCA1 Log completo: ${paths.logFile}`);
+  } catch (error) {
+    console.log("\u274C Erro ao ler arquivo de log");
+    console.log(`   ${error}`);
+  }
+}
+
+// src/commands/open.ts
+import { spawn as spawn2 } from "child_process";
+function openCommand() {
+  console.log(`\uD83C\uDF10 Abrindo AgroPlan AI no navegador...
+`);
+  const url = "https://agroplan-ai.vercel.app/dashboard";
+  try {
+    let command;
+    let args;
+    switch (process.platform) {
+      case "win32":
+        command = "cmd";
+        args = ["/c", "start", url];
+        break;
+      case "darwin":
+        command = "open";
+        args = [url];
+        break;
+      default:
+        command = "xdg-open";
+        args = [url];
+        break;
+    }
+    const child = spawn2(command, args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    console.log("\u2705 Navegador aberto!");
+    console.log(`   URL: ${url}`);
+    console.log(`
+\uD83D\uDCA1 O frontend detectar\xE1 automaticamente se a API local est\xE1 rodando`);
+  } catch (error) {
+    console.log("\u274C Erro ao abrir navegador");
+    console.log(`   Abra manualmente: ${url}`);
+  }
+}
+
+// src/commands/setup.ts
+import { existsSync as existsSync6, cpSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+async function setupCommand() {
+  console.log(`\uD83D\uDEE0\uFE0F Configurando AgroPlan AI - API Local
+`);
+  const homeDir = getHomeAgroplanDir();
+  const backendDir = join2(homeDir, "backend");
+  console.log(`\uD83D\uDCC1 Diret\xF3rio de instala\xE7\xE3o: ${homeDir}`);
+  console.log(`
+\uD83D\uDC0D Verificando Python...`);
+  const python = checkPython();
+  if (!python.available) {
+    console.log("\u274C Python n\xE3o encontrado");
+    console.log("   Instale Python 3.8+ em https://python.org/downloads");
+    return;
+  }
+  console.log(`   \u2705 ${python.version}`);
+  console.log(`
+\uD83D\uDCC2 Criando estrutura de diret\xF3rios...`);
+  ensureAgroplanDir();
+  console.log("\uD83D\uDCCB Copiando arquivos do backend...");
+  const cliDir = dirname2(dirname2(dirname2(import.meta.url.replace("file://", ""))));
+  const templateDir = join2(cliDir, "backend-template");
+  if (!existsSync6(templateDir)) {
+    console.log("\u274C Template do backend n\xE3o encontrado");
+    console.log(`   Esperado em: ${templateDir}`);
+    console.log("   Reinstale a CLI: bun add -g @kuuhaku-allan/agroplan-cli");
+    return;
+  }
+  try {
+    if (existsSync6(backendDir)) {
+      console.log("   \uD83D\uDDD1\uFE0F Removendo instala\xE7\xE3o anterior...");
+      Bun.spawnSync(["rm", "-rf", backendDir]);
+    }
+    cpSync(templateDir, backendDir, { recursive: true });
+    console.log("   \u2705 Arquivos copiados com sucesso");
+  } catch (error) {
+    console.log("\u274C Erro ao copiar arquivos do backend");
+    console.log(`   ${error}`);
+    return;
+  }
+  console.log(`
+\uD83D\uDC0D Criando ambiente virtual...`);
+  const venvPath = join2(backendDir, ".venv");
+  if (!existsSync6(venvPath)) {
+    const result = Bun.spawnSync([python.path, "-m", "venv", ".venv"], {
+      cwd: backendDir
+    });
+    if (!result.success) {
+      console.log("\u274C Falha ao criar ambiente virtual");
+      return;
+    }
+  }
+  console.log("   \u2705 Ambiente virtual criado");
+  console.log(`
+\uD83D\uDCE6 Instalando depend\xEAncias Python...`);
+  const isWindows = process.platform === "win32";
+  const pipPath = isWindows ? join2(venvPath, "Scripts", "pip.exe") : join2(venvPath, "bin", "pip");
+  const installResult = Bun.spawnSync([pipPath, "install", "-r", "requirements.txt"], {
+    cwd: backendDir
+  });
+  if (!installResult.success) {
+    console.log("\u274C Falha ao instalar depend\xEAncias");
+    console.log("   Verifique sua conex\xE3o com a internet");
+    return;
+  }
+  console.log("   \u2705 Depend\xEAncias instaladas");
+  console.log(`
+\uD83C\uDF10 Verificando servidor web...`);
+  const uvicornPath = isWindows ? join2(venvPath, "Scripts", "uvicorn.exe") : join2(venvPath, "bin", "uvicorn");
+  if (!existsSync6(uvicornPath)) {
+    console.log("\u274C Uvicorn n\xE3o encontrado");
+    return;
+  }
+  console.log("   \u2705 Servidor web configurado");
+  console.log(`
+` + "=".repeat(50));
+  console.log("\u2705 Configura\xE7\xE3o conclu\xEDda com sucesso!");
+  console.log(`
+\uD83D\uDE80 Pr\xF3ximos passos:`);
+  console.log("   agroplan serve on     # Iniciar API local");
+  console.log("   agroplan open         # Abrir no navegador");
+  console.log(`
+\uD83D\uDCA1 A API local ser\xE1 executada em http://localhost:8000`);
+}
+
+// src/index.ts
+var COMMANDS = {
+  setup: "Configura a API local no seu computador",
+  doctor: "Verifica se o sistema est\xE1 configurado corretamente",
+  "serve on": "Inicia a API local em http://localhost:8000",
+  "serve off": "Para a API local",
+  "serve status": "Mostra o status da API local e Render",
+  "serve logs": "Exibe os logs da API local",
+  open: "Abre o AgroPlan AI no navegador"
+};
+function showHelp() {
+  console.log("\uD83C\uDF31 AgroPlan AI - CLI Local v1.0.0");
+  console.log(`   Launcher para modo local acelerado
+`);
+  console.log("\uD83D\uDCCB Comandos dispon\xEDveis:");
+  Object.entries(COMMANDS).forEach(([cmd, desc]) => {
+    console.log(`   bun run agroplan ${cmd.padEnd(12)} # ${desc}`);
+  });
+  console.log(`
+\uD83C\uDFAF Fluxo recomendado:`);
+  console.log("   1. agroplan setup           # Configurar API local");
+  console.log("   2. agroplan serve on        # Iniciar API local");
+  console.log("   3. agroplan open            # Abrir no navegador");
+  console.log("   4. agroplan serve off       # Parar quando terminar");
+  console.log(`
+\uD83D\uDCA1 Modo h\xEDbrido:`);
+  console.log("   \u2022 API Local: R\xE1pida, n\xE3o dorme, ideal para uso di\xE1rio");
+  console.log("   \u2022 API Render: Fallback universal, funciona em qualquer PC");
+  console.log("   \u2022 Frontend detecta automaticamente qual usar");
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    showHelp();
+    return;
+  }
+  const command = args.join(" ");
+  try {
+    switch (command) {
+      case "setup":
+        await setupCommand();
+        break;
+      case "doctor":
+        await doctorCommand();
+        break;
+      case "serve on":
+        await serveOnCommand();
+        break;
+      case "serve off":
+        await serveOffCommand();
+        break;
+      case "serve status":
+        await serveStatusCommand();
+        break;
+      case "serve logs":
+        serveLogsCommand();
+        break;
+      case "open":
+        openCommand();
+        break;
+      case "help":
+      case "--help":
+      case "-h":
+        showHelp();
+        break;
+      default:
+        console.log(`\u274C Comando desconhecido: ${command}`);
+        console.log(`
+\uD83D\uDCA1 Use 'bun run agroplan help' para ver comandos dispon\xEDveis`);
+        process.exit(1);
+    }
+  } catch (error) {
+    console.log(`\u274C Erro ao executar comando: ${error}`);
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error("\u274C Erro fatal:", error);
+  process.exit(1);
+});