project-foundry 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-foundry",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Project Foundry CLI & Local Node Daemon Manager",
   "bin": {
     "project-foundry": "bin/foundry.js",

package/src/service-manager.js

@@ -2,6 +2,7 @@ import { execSync, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { getConfigDir } from './config.js';
 
 export async function isServerHealthy(port = 3010) {
   try {
@@ -15,13 +16,71 @@ export async function isServerHealthy(port = 3010) {
   }
 }
 
+export function stopRunningDaemon() {
+  const isWin = process.platform === 'win32';
+  if (isWin) {
+    try {
+      execSync('schtasks /end /tn "ProjectFoundry"', { stdio: 'ignore' });
+    } catch {}
+  } else {
+    try {
+      execSync('systemctl stop foundry.service', { stdio: 'ignore' });
+    } catch {}
+    try {
+      execSync('systemctl --user stop foundry.service', { stdio: 'ignore' });
+    } catch {}
+    try {
+      execSync("pkill -f 'foundry.*daemon' || true", { stdio: 'ignore' });
+    } catch {}
+  }
+}
+
+export function restartAutostartService() {
+  const isWin = process.platform === 'win32';
+  if (isWin) {
+    try {
+      execSync('schtasks /run /tn "ProjectFoundry"', { stdio: 'ignore' });
+    } catch {}
+  } else {
+    try {
+      execSync('systemctl restart foundry.service', { stdio: 'ignore' });
+    } catch {
+      try {
+        execSync('systemctl --user restart foundry.service', { stdio: 'ignore' });
+      } catch {}
+    }
+  }
+}
+
+export function ensurePermanentAppPath(entryPath) {
+  const rootDir = path.resolve(path.dirname(entryPath), '..');
+
+  // Se estiver rodando de cache temporário do npx ou temp
+  if (entryPath.includes('_npx') || entryPath.includes('npm-cache') || entryPath.includes('Temp') || entryPath.includes('tmp')) {
+    const permanentAppDir = path.join(getConfigDir(), 'app');
+    if (!fs.existsSync(permanentAppDir)) {
+      fs.mkdirSync(permanentAppDir, { recursive: true });
+    }
+    try {
+      // Copia arquivos do pacote para local permanente
+      fs.cpSync(rootDir, permanentAppDir, { recursive: true });
+      const permanentEntry = path.join(permanentAppDir, 'bin', 'foundry.js');
+      if (fs.existsSync(permanentEntry)) {
+        return permanentEntry;
+      }
+    } catch {}
+  }
+  return entryPath;
+}
+
 export function installAutostartService(serverEntryPath) {
   const isWin = process.platform === 'win32';
+  const permanentPath = ensurePermanentAppPath(serverEntryPath);
 
   if (isWin) {
     try {
       // Cria tarefa no Agendador do Windows com início automático em modo daemon
-      const cmd = `schtasks /create /tn "ProjectFoundry" /tr "node \\"${serverEntryPath}\\" daemon" /sc onstart /f`;
+      const cmd = `schtasks /create /tn "ProjectFoundry" /tr "node \\"${permanentPath}\\" daemon" /sc onstart /f`;
       execSync(cmd, { stdio: 'pipe' });
       return { success: true, type: 'windows-task', name: 'ProjectFoundry' };
     } catch (err) {
@@ -32,13 +91,14 @@ export function installAutostartService(serverEntryPath) {
   // Linux (systemd)
   try {
     const isRoot = typeof process.getuid === 'function' && process.getuid() === 0;
+    const nodeBin = process.execPath || '/usr/bin/node';
     const serviceContent = `[Unit]
-Description=Project Foundry Local Server
+Description=Project Foundry Local Farm Server
 After=network.target
 
 [Service]
 Type=simple
-ExecStart=/usr/bin/node ${serverEntryPath} daemon
+ExecStart=${nodeBin} ${permanentPath} daemon
 Restart=always
 RestartSec=5
 Environment=NODE_ENV=production
@@ -49,13 +109,13 @@ WantedBy=default.target
 
     if (isRoot) {
       fs.writeFileSync('/etc/systemd/system/foundry.service', serviceContent, 'utf8');
-      execSync('systemctl daemon-reload && systemctl enable foundry.service', { stdio: 'pipe' });
+      execSync('systemctl daemon-reload && systemctl enable foundry.service && systemctl restart foundry.service', { stdio: 'pipe' });
       return { success: true, type: 'systemd-system', name: 'foundry.service' };
     } else {
       const userSystemdDir = path.join(os.homedir(), '.config', 'systemd', 'user');
       fs.mkdirSync(userSystemdDir, { recursive: true });
       fs.writeFileSync(path.join(userSystemdDir, 'foundry.service'), serviceContent, 'utf8');
-      execSync('systemctl --user daemon-reload && systemctl --user enable foundry.service', { stdio: 'pipe' });
+      execSync('systemctl --user daemon-reload && systemctl --user enable foundry.service && systemctl --user restart foundry.service', { stdio: 'pipe' });
       return { success: true, type: 'systemd-user', name: 'foundry.service' };
     }
   } catch (err) {
@@ -64,8 +124,8 @@ WantedBy=default.target
 }
 
 export function startDaemonBackground(serverEntryPath) {
-  // Inicia desacoplado do terminal para não travar
-  const child = spawn(process.execPath, [serverEntryPath, 'daemon'], {
+  const permanentPath = ensurePermanentAppPath(serverEntryPath);
+  const child = spawn(process.execPath, [permanentPath, 'daemon'], {
     detached: true,
     stdio: 'ignore',
   });

package/src/tui.js

@@ -1,12 +1,27 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import open from 'open';
 import { readConfig, updateStoragePath } from './config.js';
-import { isServerHealthy } from './service-manager.js';
+import { isServerHealthy, stopRunningDaemon, restartAutostartService } from './service-manager.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getPackageVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    return `v${pkg.version}`;
+  } catch {
+    return 'v1.0.3';
+  }
+}
 
 export async function runInteractiveTui() {
   const config = readConfig();
-  const version = 'v1.0.0';
+  const version = getPackageVersion();
   const localPort = config?.localPort || 3010;
   const localUrl = `http://localhost:${localPort}`;
 
@@ -33,7 +48,7 @@ export async function runInteractiveTui() {
   } else {
     p.note(
       `${pc.yellow('○')} O servidor local não respondeu em ${localUrl}.\n` +
-      `Ele pode estar iniciando ou parado.`,
+      `O serviço pode estar iniciando em segundo plano ou parado.`,
       'Atenção'
     );
   }
@@ -43,16 +58,16 @@ export async function runInteractiveTui() {
       message: 'Escolha uma opção:',
       options: [
         { value: 'web', label: 'Web UI (Open in Browser)', hint: 'Abre o painel no navegador' },
-        { value: 'status', label: 'Terminal UI (Status & Health)', hint: 'Verifica conexões locais' },
+        { value: 'status', label: 'Terminal UI (Status & Health)', hint: 'Verifica saúde e conexões locais' },
         { value: 'storage', label: 'Storage (HD Externo)', hint: 'Visualizar ou alterar pasta de arquivos' },
-        { value: 'update', label: `Update (current: ${version})`, hint: 'Verifica atualizações' },
-        { value: 'hide', label: 'Hide to Tray (Background)', hint: 'Mantém servidor rodando em segundo plano' },
-        { value: 'exit', label: 'Exit', hint: 'Fechar console' },
+        { value: 'update', label: `Update (current: ${version})`, hint: 'Verifica e atualiza para versão mais recente' },
+        { value: 'hide', label: 'Hide to Tray (Background)', hint: 'Fecha o console e mantém o servidor rodando' },
+        { value: 'stop', label: 'Stop Server', hint: 'Desliga o servidor local da farm' },
       ],
     });
 
     if (p.isCancel(choice) || choice === 'hide') {
-      p.outro(pc.green('Servidor mantido rodando em segundo plano. Digite "foundry" para reabrir este menu.'));
+      p.outro(pc.green('Painel fechado. O servidor da farm continua rodando em segundo plano.'));
       process.exit(0);
     }
 
@@ -100,19 +115,56 @@ export async function runInteractiveTui() {
     }
 
     if (choice === 'update') {
-      p.log.info('Você já está na versão mais recente instalada.');
+      const s = p.spinner();
+      s.start('Verificando versão mais recente no npm...');
+      try {
+        const res = await fetch('https://registry.npmjs.org/project-foundry/latest', {
+          signal: AbortSignal.timeout(6000),
+        });
+        const data = await res.json();
+        const latestVersion = `v${data.version}`;
+        s.stop();
+
+        if (latestVersion !== version) {
+          p.log.warn(`Nova versão disponível: ${pc.green(latestVersion)} (você está na ${version})`);
+          const doUpdate = await p.confirm({
+            message: `Deseja atualizar para a versão ${latestVersion}?`,
+            initialValue: true,
+          });
+
+          if (doUpdate && !p.isCancel(doUpdate)) {
+            s.start('Atualizando pacote e reiniciando serviço...');
+            try {
+              execSync('npm install -g project-foundry@latest', { stdio: 'pipe' });
+              restartAutostartService();
+              s.stop(pc.green(`Atualizado para ${latestVersion} com sucesso!`));
+              p.outro(pc.cyan('Reinicie o menu com "foundry" ou "npx project-foundry" para aplicar.'));
+              process.exit(0);
+            } catch (err) {
+              s.stop(pc.yellow(`Atualização global não permitida sem sudo. Execute no terminal: npm install -g project-foundry@latest`));
+            }
+          }
+        } else {
+          p.log.success(`Você já está na versão mais recente (${version}).`);
+        }
+      } catch (err) {
+        s.stop(pc.red(`Erro ao verificar: ${err.message}`));
+      }
     }
 
-    if (choice === 'exit') {
+    if (choice === 'stop') {
       const shouldStop = await p.confirm({
-        message: 'Deseja apenas fechar o console ou parar o serviço?',
-        active: 'Apenas fechar console (manter servidor ligado)',
-        inactive: 'Fechar console',
-        initialValue: true,
+        message: 'Atenção: deseja realmente parar o servidor local da farm?',
+        active: 'Sim, parar servidor completamente',
+        inactive: 'Não, manter ligado',
+        initialValue: false,
       });
 
-      p.outro(pc.cyan('Até logo! O servidor continua em segundo plano.'));
-      process.exit(0);
+      if (shouldStop && !p.isCancel(shouldStop)) {
+        stopRunningDaemon();
+        p.outro(pc.yellow('Servidor local encerrado. Para religar, execute "foundry" no terminal.'));
+        process.exit(0);
+      }
     }
   }
 }