@nicolasarths/devserver 1.0.0 → 1.0.2

package/auto-updater.js

@@ -0,0 +1,149 @@
+/**
+ * Auto-Updater do Pacote @nicolasarths/devserver
+ * Responsabilidade: Verificar no registro NPM (com trava de 60s) se há versão mais recente,
+ * baixar e atualizar a pasta server/ local antes dos processos pós-save.
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const PACKAGE_NAME = "@nicolasarths/devserver";
+const REGISTRY_URL = "https://registry.npmjs.org/@nicolasarths%2Fdevserver/latest";
+const COOLDOWN_MS = 60 * 1000;
+
+let ultimaVerificacaoTimestamp = 0;
+let atualizacaoEmAndamento = false;
+
+function obterVersaoLocal(rootDir) {
+  const candidatos = [
+    path.join(__dirname, "package.json"),
+    path.join(rootDir, "server", "package.json"),
+    path.join(rootDir, "package.json")
+  ];
+
+  for (const pkgPath of candidatos) {
+    if (!fs.existsSync(pkgPath)) continue;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.name === PACKAGE_NAME && pkg.version) {
+        return pkg.version;
+      }
+    } catch (_) {}
+  }
+  return null;
+}
+
+function compararSemver(remota, local) {
+  const r = String(remota).split(".").map((n) => parseInt(n, 10) || 0);
+  const l = String(local).split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((r[i] || 0) > (l[i] || 0)) return 1;
+    if ((r[i] || 0) < (l[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+function copiarArquivosAtualizados(origemDir, destinoDir) {
+  const itens = fs.readdirSync(origemDir, { withFileTypes: true });
+  for (const item of itens) {
+    const srcPath = path.join(origemDir, item.name);
+    const destPath = path.join(destinoDir, item.name);
+
+    if (item.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      copiarArquivosAtualizados(srcPath, destPath);
+    } else if (item.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function limparCacheModulosServer(serverDir) {
+  Object.keys(require.cache).forEach((chave) => {
+    if (chave.startsWith(serverDir) && !chave.endsWith("auto-updater.js")) {
+      delete require.cache[chave];
+    }
+  });
+}
+
+async function baixarEAplicarAtualizacao(tarballUrl, destinoServerDir, novaVersao) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "nic-devserver-"));
+  const tgzPath = path.join(tempDir, "package.tgz");
+  const extractDir = path.join(tempDir, "extracted");
+
+  try {
+    const res = await fetch(tarballUrl);
+    if (!res.ok) throw new Error(`HTTP ${res.status} ao baixar tarball`);
+
+    const buffer = Buffer.from(await res.arrayBuffer());
+    fs.writeFileSync(tgzPath, buffer);
+    fs.mkdirSync(extractDir, { recursive: true });
+
+    execSync(`tar -xzf "${tgzPath}" -C "${extractDir}"`, { stdio: "ignore" });
+
+    const packageRoot = path.join(extractDir, "package");
+    if (!fs.existsSync(packageRoot)) {
+      throw new Error("Estrutura do pacote extraído inválida.");
+    }
+
+    fs.mkdirSync(destinoServerDir, { recursive: true });
+    copiarArquivosAtualizados(packageRoot, destinoServerDir);
+    limparCacheModulosServer(destinoServerDir);
+
+    console.log(`🔄 [Auto-Update] Pasta server/ atualizada para v${novaVersao} com sucesso!`);
+    return true;
+  } finally {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch (_) {}
+  }
+}
+
+async function verificarEAtualizarServidor(rootDir, config) {
+  if (config?.isNpmPackage) return false;
+
+  const agora = Date.now();
+  if (atualizacaoEmAndamento || agora - ultimaVerificacaoTimestamp < COOLDOWN_MS) {
+    return false;
+  }
+
+  ultimaVerificacaoTimestamp = agora;
+  atualizacaoEmAndamento = true;
+
+  try {
+    const versaoLocal = obterVersaoLocal(rootDir);
+    if (!versaoLocal) return false;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 4000);
+
+    const res = await fetch(REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { "Cache-Control": "no-cache" }
+    });
+    clearTimeout(timeout);
+
+    if (!res.ok) return false;
+
+    const meta = await res.json();
+    const versaoRemota = meta?.version;
+    const tarballUrl = meta?.dist?.tarball;
+
+    if (!versaoRemota || !tarballUrl) return false;
+
+    if (compararSemver(versaoRemota, versaoLocal) > 0) {
+      console.log(`\n⬆️ [Auto-Update] Nova versão encontrada no NPM: v${versaoRemota} (local: v${versaoLocal})`);
+      const pastaServerAlvo = path.join(rootDir, "server");
+      return await baixarEAplicarAtualizacao(tarballUrl, pastaServerAlvo, versaoRemota);
+    }
+
+    return false;
+  } catch (_) {
+    return false;
+  } finally {
+    atualizacaoEmAndamento = false;
+  }
+}
+
+module.exports = { verificarEAtualizarServidor };

package/builder.js

@@ -1,6 +1,6 @@
 /**
  * Gerador de Snapshot e Hooks de Build
- * Responsabilidade: Gerar projeto_completo.txt na raiz do projeto e executar hooks opcionais (ex: modulos.json).
+ * Responsabilidade: Apagar o snapshot anterior, gerar projeto_completo.txt limpo na raiz do projeto e executar hooks opcionais.
  */
 const fs = require("fs");
 const path = require("path");
@@ -51,6 +51,12 @@ function gerarProjetoCompleto(rootDir, extensoesValidas = [".js", ".html", ".css
 
   try {
     const destino = path.join(rootDir, "projeto_completo.txt");
+
+    // Apaga fisicamente o snapshot anterior antes de gerar o novo
+    if (fs.existsSync(destino)) {
+      fs.unlinkSync(destino);
+    }
+
     let output = "";
 
     const ignorarNomes = new Set([

package/config.js

@@ -1,6 +1,7 @@
 /**
  * Gerenciador de Configuração por Projeto
- * Responsabilidade: Detectar metadados do projeto via process.cwd() e persistir ajustes em .devserver.json na raiz do projeto.
+ * Responsabilidade: Detectar automaticamente se o projeto atual é um pacote NPM ou um projeto Web/GitHub
+ * e persistir apenas metadados básicos em .devserver.json.
  */
 const fs = require("fs");
 const path = require("path");
@@ -29,40 +30,77 @@ function detectarGitRemote(rootDir) {
   return null;
 }
 
+function detectarModoPacoteNpm(rootDir) {
+  const candidatos = [rootDir, path.join(rootDir, "server")];
+  for (const dir of candidatos) {
+    const pkgPath = path.join(dir, "package.json");
+    if (!fs.existsSync(pkgPath)) continue;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      const isPacotePublico =
+        pkg.name === "@nicolasarths/devserver" ||
+        Boolean(pkg.bin && pkg.publishConfig?.access === "public");
+
+      if (isPacotePublico) {
+        return {
+          isNpmPackage: true,
+          npmPackageDir: dir,
+          packageName: pkg.name
+        };
+      }
+    } catch (_) {}
+  }
+  return {
+    isNpmPackage: false,
+    npmPackageDir: "",
+    packageName: ""
+  };
+}
+
 function carregarConfig(rootDir) {
   const configPath = path.join(rootDir, CONFIG_FILENAME);
   const nomePastaRaiz = path.basename(rootDir);
   const gitInfo = detectarGitRemote(rootDir);
+  const modoNpm = detectarModoPacoteNpm(rootDir);
 
-  const padrao = {
-    projectName: nomePastaRaiz,
-    port: 8081,
-    githubUser: gitInfo?.githubUser || "",
-    repoName: gitInfo?.repoName || nomePastaRaiz,
-    branch: "main",
-    pagesCheckFile: fs.existsSync(path.join(rootDir, "manifest.json")) ? "manifest.json" : "index.html",
-    snapshotExtensions: [".js", ".html", ".css", ".json", ".ts", ".jsx", ".tsx", ".md"]
-  };
-
+  let salvo = {};
   if (fs.existsSync(configPath)) {
     try {
-      const salvo = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-      return { ...padrao, ...salvo };
+      salvo = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      // Remove eventual resquício antigo de autoNpmPublish manual
+      delete salvo.autoNpmPublish;
+      delete salvo.npmPackageDir;
     } catch (_) {}
   }
 
-  salvarConfig(rootDir, padrao);
-  return padrao;
+  const configFinal = {
+    projectName: salvo.projectName || nomePastaRaiz,
+    port: salvo.port || 8081,
+    githubUser: salvo.githubUser || gitInfo?.githubUser || "",
+    repoName: salvo.repoName || gitInfo?.repoName || nomePastaRaiz,
+    branch: salvo.branch || "main",
+    pagesCheckFile: salvo.pagesCheckFile || (fs.existsSync(path.join(rootDir, "manifest.json")) ? "manifest.json" : "index.html"),
+    snapshotExtensions: salvo.snapshotExtensions || [".js", ".html", ".css", ".json", ".ts", ".jsx", ".tsx", ".md"],
+    // Propriedades dinâmicas inferidas automaticamente (não dependem de configuração manual)
+    isNpmPackage: modoNpm.isNpmPackage,
+    npmPackageDir: modoNpm.npmPackageDir,
+    packageName: modoNpm.packageName
+  };
+
+  salvarConfig(rootDir, configFinal);
+  return configFinal;
 }
 
 function salvarConfig(rootDir, novaConfig) {
   const configPath = path.join(rootDir, CONFIG_FILENAME);
-  fs.writeFileSync(configPath, JSON.stringify(novaConfig, null, 2), "utf-8");
+  const { isNpmPackage, npmPackageDir, packageName, ...persistir } = novaConfig;
+  fs.writeFileSync(configPath, JSON.stringify(persistir, null, 2), "utf-8");
 }
 
 module.exports = {
   CONFIG_FILENAME,
   carregarConfig,
   salvarConfig,
-  detectarGitRemote
+  detectarGitRemote,
+  detectarModoPacoteNpm
 };

package/deploy.js

@@ -1,17 +1,16 @@
 /**
- * CLI Interativa de Deploy e Monitoramento do GitHub Pages
- * Responsabilidade: Garantir identidade Git no boot/commit, versionar arquivos, executar git push e monitorar Pages.
+ * Motor de Deploy, NPM Auto-Publish e Monitoramento do GitHub Pages
+ * Responsabilidade: Garantir configuração GitHub automaticamente se ausente, versionar, publicar no Git/NPM e monitorar Pages.
  */
 const fs = require("fs");
 const path = require("path");
-const readline = require("readline");
 const { execSync } = require("child_process");
 const { executarHooksOpcionais, gerarProjetoCompleto } = require("./builder");
 const { executarAssistenteGitHub, garantirIdentidadeGit } = require("./github");
-const { detectarGitRemote } = require("./config");
+const { detectarGitRemote, detectarModoPacoteNpm } = require("./config");
 
 async function aguardarDeployGitHubPages(versaoAlvo, config) {
-  if (!config.githubUser || !config.repoName) return;
+  if (!config.githubUser || !config.repoName || config.isNpmPackage) return;
 
   const checkFile = config.pagesCheckFile || "index.html";
   const urlBase = `https://${config.githubUser}.github.io/${config.repoName}`;
@@ -74,24 +73,65 @@ async function aguardarDeployGitHubPages(versaoAlvo, config) {
   }, intervaloMs);
 }
 
+function incrementarVersaoPacoteNpm(pkgDir) {
+  const pkgPath = path.join(pkgDir, "package.json");
+  if (!fs.existsSync(pkgPath)) return null;
+
+  try {
+    execSync("npm version patch --no-git-tag-version", { cwd: pkgDir, stdio: "ignore" });
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    console.log(`📦 [NPM] Versão do pacote incrementada para: ${pkg.version}`);
+    return pkg.version;
+  } catch (err) {
+    console.error(`⚠️ Não foi possível incrementar versão no package.json:`, err.message);
+    return null;
+  }
+}
+
+function publicarNoNpm(pkgDir, versao) {
+  try {
+    console.log(`🚀 [NPM] Publicando v${versao} no registro do npm...`);
+    execSync("npm publish --access public", { cwd: pkgDir, stdio: "inherit" });
+    console.log(`🎉 [NPM PUBLICADO!] v${versao} já está disponível via npx!\n`);
+  } catch (err) {
+    console.error(`❌ Falha ao publicar no npm:`, err.message);
+  }
+}
+
 async function publicarAtualizacao(rl, mensagemCommit, rootDir, config) {
-  const remote = detectarGitRemote(rootDir);
+  let configAtual = config;
+  let remote = detectarGitRemote(rootDir);
+
   if (!remote) {
     console.log(`\n⚠️ Nenhum repositório remoto configurado neste projeto ainda!`);
-    console.log(`👉 Digite /github no terminal para configurar ou criar o repositório agora.\n`);
-    return;
+    console.log(`🔧 Iniciando configuração automática do GitHub antes de publicar "${mensagemCommit}"...\n`);
+    configAtual = await executarAssistenteGitHub(rl, rootDir, configAtual);
+    remote = detectarGitRemote(rootDir);
+
+    if (!remote) {
+      console.log(`❌ Publicação interrompida porque nenhum repositório foi vinculado.\n`);
+      return configAtual;
+    }
   }
 
-  // Garante que user.name e user.email globais estejam preenchidos antes de tentar commitar
   await garantirIdentidadeGit(rl, rootDir);
 
   const agora = new Date();
   const pad = (n) => String(n).padStart(2, "0");
   const timestampVersao = `${agora.getFullYear()}.${agora.getMonth() + 1}.${agora.getDate()}-${pad(agora.getHours())}${pad(agora.getMinutes())}`;
 
-  console.log(`\n📦 [Deploy ${config.projectName}] Publicando: "${mensagemCommit}"`);
+  console.log(`\n📦 [Deploy ${configAtual.projectName}] Publicando: "${mensagemCommit}"`);
   console.log(`🏷️ Versão gerada: v${timestampVersao}`);
 
+  const modoNpm = configAtual.isNpmPackage
+    ? { isNpmPackage: true, npmPackageDir: configAtual.npmPackageDir }
+    : detectarModoPacoteNpm(rootDir);
+
+  let versaoNpm = null;
+  if (modoNpm.isNpmPackage && modoNpm.npmPackageDir) {
+    versaoNpm = incrementarVersaoPacoteNpm(modoNpm.npmPackageDir);
+  }
+
   const indexPath = path.join(rootDir, "index.html");
   if (fs.existsSync(indexPath)) {
     let indexHtml = fs.readFileSync(indexPath, "utf-8");
@@ -116,82 +156,40 @@ async function publicarAtualizacao(rl, mensagemCommit, rootDir, config) {
   }
 
   executarHooksOpcionais(rootDir);
-  gerarProjetoCompleto(rootDir, config.snapshotExtensions);
+  gerarProjetoCompleto(rootDir, configAtual.snapshotExtensions);
 
   try {
-    const branch = config.branch || "main";
+    const branch = configAtual.branch || "main";
     execSync("git add .", { stdio: "inherit", cwd: rootDir });
 
-    const commitMsgFormatada = `v${timestampVersao}: ${mensagemCommit}`;
+    const statusPorcelain = execSync("git status --porcelain", { cwd: rootDir }).toString().trim();
+    if (!statusPorcelain) {
+      console.log(`ℹ️ Nenhuma alteração nova pendente após o setup inicial.`);
+      if (modoNpm.isNpmPackage && versaoNpm) {
+        publicarNoNpm(modoNpm.npmPackageDir, versaoNpm);
+      }
+      return configAtual;
+    }
+
+    const tagMsg = versaoNpm ? `v${versaoNpm}` : `v${timestampVersao}`;
+    const commitMsgFormatada = `${tagMsg}: ${mensagemCommit}`;
     execSync(`git commit -m "${commitMsgFormatada.replace(/"/g, '\\"')}"`, { stdio: "inherit", cwd: rootDir });
 
     console.log(`🚀 Enviando para origin/${branch}...`);
     execSync(`git push -u origin ${branch}`, { stdio: "inherit", cwd: rootDir });
 
-    console.log(`✅ Push concluído com sucesso!`);
-    aguardarDeployGitHubPages(timestampVersao, config);
-  } catch (err) {
-    console.error(`\n❌ Falha durante o deploy do Git:`, err.message);
-  }
-}
-
-async function iniciarCLI(rootDir, configInicial) {
-  let configAtual = configInicial;
-  let bloqueadoPorAssistente = false;
-
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  // Verifica logo ao subir o servidor se o Git global já tem nome e e-mail salvos
-  bloqueadoPorAssistente = true;
-  try {
-    await garantirIdentidadeGit(rl, rootDir);
-  } finally {
-    bloqueadoPorAssistente = false;
-  }
-
-  rl.on("line", async (linha) => {
-    if (bloqueadoPorAssistente) return;
-
-    const msg = linha.trim();
-    if (!msg) return;
+    console.log(`✅ Push no GitHub concluído com sucesso!`);
 
-    const cmd = msg.toLowerCase();
-
-    if (cmd === "cls" || cmd === "clear") {
-      console.clear();
-      return;
-    }
-
-    if (cmd === "/github" || cmd === "/setup") {
-      bloqueadoPorAssistente = true;
-      try {
-        configAtual = await executarAssistenteGitHub(rl, rootDir, configAtual);
-      } finally {
-        bloqueadoPorAssistente = false;
-      }
-      return;
-    }
-
-    if (cmd === "/status") {
-      const remote = detectarGitRemote(rootDir);
-      console.log(`\n📊 Status do Projeto (${configAtual.projectName}):`);
-      console.log(`   • Usuário GitHub: ${configAtual.githubUser || "(não configurado)"}`);
-      console.log(`   • Repositório:    ${configAtual.repoName || "(não configurado)"}`);
-      console.log(`   • Remote Origin:  ${remote ? remote.remoteUrl : "(não vinculado — digite /github)"}`);
-      console.log(`   • Branch:         ${configAtual.branch || "main"}\n`);
-      return;
+    if (modoNpm.isNpmPackage && versaoNpm) {
+      publicarNoNpm(modoNpm.npmPackageDir, versaoNpm);
+    } else {
+      aguardarDeployGitHubPages(timestampVersao, configAtual);
     }
+  } catch (err) {
+    console.error(`\n❌ Falha durante o deploy:`, err.message);
+  }
 
-    bloqueadoPorAssistente = true;
-    try {
-      await publicarAtualizacao(rl, msg, rootDir, configAtual);
-    } finally {
-      bloqueadoPorAssistente = false;
-    }
-  });
+  return configAtual;
 }
 
-module.exports = { iniciarCLI };
+module.exports = { publicarAtualizacao };

package/github/index.js

@@ -1,6 +1,6 @@
 /**
- * Orquestrador do Assistente GitHub (/github)
- * Responsabilidade: Conduzir o menu interativo de criação/vinculação de repositório conectando os submódulos.
+ * Orquestrador do Assistente GitHub
+ * Responsabilidade: Conduzir o menu interativo de criação/vinculação de repositório e persistir o token globalmente no Windows.
  */
 const path = require("path");
 const { execSync } = require("child_process");
@@ -10,6 +10,31 @@ const { garantirIdentidadeGit } = require("./git-identity");
 const { garantirGitIgnore, garantirGitLocal, configurarOrigin } = require("./git-local");
 const { criarRepositorioRemotoGitHub, ativarGitHubPages } = require("./github-api");
 
+function lerTokenGlobalWindows() {
+  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+  try {
+    const out = execSync('reg query "HKCU\\Environment" /v GITHUB_TOKEN', {
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString();
+    const match = out.match(/GITHUB_TOKEN\s+REG_SZ\s+(\S+)/);
+    if (match) {
+      process.env.GITHUB_TOKEN = match[1];
+      return match[1];
+    }
+  } catch (_) {}
+  return "";
+}
+
+function salvarTokenGlobalWindows(token) {
+  process.env.GITHUB_TOKEN = token;
+  try {
+    execSync(`setx GITHUB_TOKEN "${token}"`, { stdio: "ignore" });
+    console.log("✅ Token salvo globalmente no Windows (nunca mais será pedido em nenhum projeto!).");
+  } catch (err) {
+    console.log(`⚠️ Não foi possível gravar no registro do Windows: ${err.message}`);
+  }
+}
+
 async function executarAssistenteGitHub(rl, rootDir, config) {
   console.log(`\n==================================================`);
   console.log(`🐙 ASSISTENTE DE CONFIGURAÇÃO GITHUB`);
@@ -49,9 +74,12 @@ async function executarAssistenteGitHub(rl, rootDir, config) {
     const pagesInput = await perguntar(rl, `🌐 Ativar GitHub Pages automaticamente? (S/n): `);
     const ativarPages = pagesInput.toLowerCase() !== "n";
 
-    let token = process.env.GITHUB_TOKEN || config.githubToken || "";
+    let token = lerTokenGlobalWindows() || config.githubToken || "";
+    let tokenNovo = false;
+
     if (!token) {
       token = await perguntar(rl, `🔑 Cole seu GitHub Personal Access Token (scope 'repo'): `);
+      tokenNovo = Boolean(token);
     }
 
     if (!token) {
@@ -68,15 +96,16 @@ async function executarAssistenteGitHub(rl, rootDir, config) {
         privado
       });
 
-      configurarOrigin(rootDir, criado.cloneUrl);
+      if (tokenNovo) {
+        salvarTokenGlobalWindows(token);
+      }
 
-      const salvarToken = await perguntar(rl, `💾 Salvar token no .devserver.json deste projeto (ignorado pelo git)? (s/N): `);
+      configurarOrigin(rootDir, criado.cloneUrl);
 
       const novaConfig = {
         ...config,
         githubUser: criado.githubUser,
-        repoName: criado.repoName,
-        ...(salvarToken.toLowerCase() === "s" ? { githubToken: token } : {})
+        repoName: criado.repoName
       };
       salvarConfig(rootDir, novaConfig);
 

package/index.js

@@ -2,15 +2,14 @@
 
 /**
  * Ponto de Entrada do Universal Dev Server
- * Responsabilidade: Inicializar build, watcher, servidor HTTP com fallback de porta e CLI interativa na pasta atual.
+ * Responsabilidade: Inicializar build, watcher, servidor HTTP com fallback de porta e menu interativo na pasta atual.
  */
-const { carregarConfig, detectarGitRemote } = require("./config");
+const { carregarConfig } = require("./config");
 const { criarServidorHttp } = require("./http");
 const { executarHooksOpcionais, gerarProjetoCompleto } = require("./builder");
 const { iniciarWatcher } = require("./watcher");
-const { iniciarCLI } = require("./deploy");
+const { iniciarMenuInterativo } = require("./menu");
 
-// Sempre aponta para a pasta onde o terminal foi executado (seja no próprio server ou em qualquer projeto)
 const ROOT_DIR = process.cwd();
 const config = carregarConfig(ROOT_DIR);
 
@@ -35,30 +34,13 @@ function iniciarEscuta(portaAtual) {
   });
 
   server.listen(portaAtual, () => {
-    const remote = detectarGitRemote(ROOT_DIR);
-
     console.log(`\n==================================================`);
     console.log(`⚡ Dev Server [${config.projectName}] rodando em:`);
     console.log(`   👉 http://localhost:${portaAtual}`);
-    console.log(`📝 projeto_completo.txt gerado em: ${ROOT_DIR}`);
-    console.log(`--------------------------------------------------`);
-
-    if (remote) {
-      console.log(`🐙 GitHub vinculado: ${remote.githubUser}/${remote.repoName}`);
-    } else {
-      console.log(`⚠️ GitHub NÃO configurado neste projeto.`);
-      console.log(`   Digite /github para criar ou vincular um repo!`);
-    }
-
-    console.log(`--------------------------------------------------`);
-    console.log(`💬 COMANDOS DISPONÍVEIS NO TERMINAL:`);
-    console.log(`   • <mensagem> + ENTER ➔ Versiona, commita e faz push`);
-    console.log(`   • /github            ➔ Cria repo no GitHub ou vincula existente`);
-    console.log(`   • /status            ➔ Exibe configurações do repositório`);
-    console.log(`   • cls                ➔ Limpa o terminal`);
-    console.log(`==================================================\n`);
+    console.log(`📝 projeto_completo.txt sincronizado.`);
+    console.log(`==================================================`);
 
-    iniciarCLI(ROOT_DIR, config);
+    iniciarMenuInterativo(ROOT_DIR, config);
   });
 }
 

package/menu.js

@@ -0,0 +1,138 @@
+/**
+ * Menu Interativo do Terminal
+ * Responsabilidade: Exibir o modo detectado automaticamente (Pacote NPM vs Projeto Web/GitHub) e rotear opções do usuário.
+ */
+const readline = require("readline");
+const { salvarConfig, detectarGitRemote } = require("./config");
+const { executarAssistenteGitHub, garantirIdentidadeGit } = require("./github");
+const { perguntar } = require("./github/prompts");
+const { publicarAtualizacao } = require("./deploy");
+
+const MENSAGEM_PADRAO = "Update sem descrição";
+
+function exibirMenu(rootDir, config) {
+  const remote = detectarGitRemote(rootDir);
+  const statusGit = remote
+    ? `${remote.githubUser}/${remote.repoName} (branch: ${config.branch || "main"})`
+    : "Não vinculado (escolha [2] para configurar)";
+
+  const modoDetectado = config.isNpmPackage
+    ? `📦 Pacote NPM (${config.packageName}) ➔ GitHub + Auto-Publish NPM`
+    : `🌐 Projeto Web/GitHub ➔ GitHub + Monitor GitHub Pages`;
+
+  console.log(`\n--------------------------------------------------`);
+  console.log(`🔍 Modo:   ${modoDetectado}`);
+  console.log(`🐙 GitHub: ${statusGit}`);
+  console.log(`--------------------------------------------------`);
+  console.log(`📋 O QUE VOCÊ DESEJA FAZER?`);
+  console.log(`  [1] 🚀 Publicar alteração (pedir mensagem de commit)`);
+  console.log(`  [2] 🐙 Configurar / Criar repositório no GitHub`);
+  console.log(`  [3] ⚙️  Configurar porta, branch ou projeto`);
+  console.log(`  [4] 📊 Ver status detalhado`);
+  console.log(`  [5] 🧹 Limpar tela`);
+  console.log(`  [0] ❌ Sair e encerrar servidor`);
+  console.log(`  💡 Atalho: digite a mensagem e dê ENTER (ou só ENTER para "${MENSAGEM_PADRAO}")`);
+  console.log(`--------------------------------------------------`);
+}
+
+async function configurarOpcoesProjeto(rl, rootDir, config) {
+  console.log(`\n⚙️ CONFIGURAÇÕES DO PROJETO (${config.projectName})`);
+  const porta = await perguntar(rl, `🔌 Porta HTTP [${config.port || 8081}]: `);
+  const branch = await perguntar(rl, `🌿 Branch principal [${config.branch || "main"}]: `);
+  const user = await perguntar(rl, `👤 Usuário GitHub [${config.githubUser}]: `);
+  const repo = await perguntar(rl, `📦 Nome do repositório [${config.repoName}]: `);
+
+  const novaConfig = {
+    ...config,
+    port: Number(porta) || config.port || 8081,
+    branch: branch || config.branch || "main",
+    githubUser: user || config.githubUser,
+    repoName: repo || config.repoName
+  };
+
+  salvarConfig(rootDir, novaConfig);
+  console.log(`✅ Configurações salvas em .devserver.json! (Se mudou a porta, reinicie o servidor).`);
+  return novaConfig;
+}
+
+async function iniciarMenuInterativo(rootDir, configInicial) {
+  let configAtual = configInicial;
+  let ocupado = false;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  ocupado = true;
+  try {
+    await garantirIdentidadeGit(rl, rootDir);
+  } finally {
+    ocupado = false;
+  }
+
+  exibirMenu(rootDir, configAtual);
+
+  rl.on("line", async (linha) => {
+    if (ocupado) return;
+
+    const entrada = linha.trim();
+
+    ocupado = true;
+    try {
+      if (entrada === "0") {
+        console.log("\n👋 Encerrando servidor...");
+        process.exit(0);
+      }
+
+      if (entrada === "1") {
+        const msg = await perguntar(rl, `\n📝 Digite a mensagem do commit [${MENSAGEM_PADRAO}]: `);
+        configAtual = await publicarAtualizacao(rl, msg || MENSAGEM_PADRAO, rootDir, configAtual);
+        exibirMenu(rootDir, configAtual);
+        return;
+      }
+
+      if (entrada === "2") {
+        configAtual = await executarAssistenteGitHub(rl, rootDir, configAtual);
+        exibirMenu(rootDir, configAtual);
+        return;
+      }
+
+      if (entrada === "3") {
+        configAtual = await configurarOpcoesProjeto(rl, rootDir, configAtual);
+        exibirMenu(rootDir, configAtual);
+        return;
+      }
+
+      if (entrada === "4") {
+        const remote = detectarGitRemote(rootDir);
+        console.log(`\n📊 STATUS DETALHADO:`);
+        console.log(`   • Pasta Raiz:     ${rootDir}`);
+        console.log(`   • Projeto:        ${configAtual.projectName}`);
+        console.log(`   • Tipo Detectado: ${configAtual.isNpmPackage ? `Pacote NPM (${configAtual.packageName})` : "Projeto Web / GitHub"}`);
+        console.log(`   • Porta Config:   ${configAtual.port}`);
+        console.log(`   • Usuário GitHub: ${configAtual.githubUser || "(não definido)"}`);
+        console.log(`   • Repositório:    ${configAtual.repoName || "(não definido)"}`);
+        console.log(`   • Remote Origin:  ${remote ? remote.remoteUrl : "(não vinculado)"}`);
+        console.log(`   • Branch:         ${configAtual.branch || "main"}`);
+        exibirMenu(rootDir, configAtual);
+        return;
+      }
+
+      if (entrada === "5") {
+        console.clear();
+        exibirMenu(rootDir, configAtual);
+        return;
+      }
+
+      // Se apertar apenas ENTER (vazio) ou digitar texto livre, publica direto!
+      const mensagemFinal = entrada || MENSAGEM_PADRAO;
+      configAtual = await publicarAtualizacao(rl, mensagemFinal, rootDir, configAtual);
+      exibirMenu(rootDir, configAtual);
+    } finally {
+      ocupado = false;
+    }
+  });
+}
+
+module.exports = { iniciarMenuInterativo };

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@nicolasarths/devserver",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Servidor de desenvolvimento com live-reload e deploy automático para GitHub Pages",
   "main": "index.js",
   "bin": {
-    "nic-dev": "./index.js"
+    "devserver": "index.js",
+    "nic-dev": "index.js"
   },
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/watcher.js

@@ -1,16 +1,16 @@
 /**
  * Monitor de Sistema de Arquivos (File Watcher)
- * Responsabilidade: Detectar modificações no código-fonte e disparar hooks, snapshot e Live Reload.
+ * Responsabilidade: Detectar modificações no código-fonte, checar auto-update do servidor e disparar build + Live Reload.
  */
 const fs = require("fs");
-const { executarHooksOpcionais, gerarProjetoCompleto } = require("./builder");
-const { notificarRecarregamento } = require("./livereload");
+const { verificarEAtualizarServidor } = require("./auto-updater");
 
 function iniciarWatcher(rootDir, config) {
   let watchTimeout = null;
+  let ignorarEventosInternos = false;
 
   fs.watch(rootDir, { recursive: true }, (eventType, filename) => {
-    if (!filename) return;
+    if (!filename || ignorarEventosInternos) return;
 
     const norm = filename.replace(/\\/g, "/").toLowerCase();
 
@@ -26,10 +26,26 @@ function iniciarWatcher(rootDir, config) {
     }
 
     clearTimeout(watchTimeout);
-    watchTimeout = setTimeout(() => {
-      executarHooksOpcionais(rootDir);
-      gerarProjetoCompleto(rootDir, config.snapshotExtensions);
-      notificarRecarregamento();
+    watchTimeout = setTimeout(async () => {
+      ignorarEventosInternos = true;
+      try {
+        // 1. Verifica e atualiza a pasta server/ se houver versão nova no NPM (com trava de 60s)
+        await verificarEAtualizarServidor(rootDir, config);
+
+        // 2. Carrega dinamicamente builder e livereload (já pegando a versão nova se houve update)
+        const { executarHooksOpcionais, gerarProjetoCompleto } = require("./builder");
+        const { notificarRecarregamento } = require("./livereload");
+
+        // 3. Executa os processos pós-save normalmente
+        executarHooksOpcionais(rootDir);
+        gerarProjetoCompleto(rootDir, config.snapshotExtensions);
+        notificarRecarregamento();
+      } finally {
+        // Pequena janela para absorver eventos residualmente disparados pela cópia dos arquivos
+        setTimeout(() => {
+          ignorarEventosInternos = false;
+        }, 300);
+      }
     }, 250);
   });
 }