project-foundry 1.0.2 → 1.0.4

package/bin/foundry.js

@@ -17,7 +17,7 @@ program
   .description('Project Foundry CLI & Edge Node Manager')
   .version('1.0.0');
 
-// Comando: daemon (segundo plano)
+// Comando: daemon
 program
   .command('daemon')
   .description('Inicia o servidor e o túnel reverso em segundo plano')
@@ -25,6 +25,28 @@ program
     startDaemon();
   });
 
+// Comando: start (inicia o daemon diretamente exibindo logs em tempo real)
+program
+  .command('start')
+  .description('Inicia o servidor local e o túnel com logs visíveis no terminal')
+  .action(() => {
+    console.log(pc.bold(pc.cyan('Iniciando Project Foundry Local Server...')));
+    startDaemon();
+  });
+
+// Comando: service-install
+program
+  .command('service-install')
+  .description('Instala ou atualiza o serviço de autostart no sistema operacional')
+  .action(() => {
+    const res = installAutostartService(process.argv[1]);
+    if (res.success) {
+      console.log(pc.green(`Serviço registrado com sucesso (${res.type}): ${res.name}`));
+    } else {
+      console.error(pc.red(`Falha ao registrar serviço: ${res.error}`));
+    }
+  });
+
 // Comando: setup
 program
   .command('setup')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-foundry",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Project Foundry CLI & Local Node Daemon Manager",
   "bin": {
     "project-foundry": "bin/foundry.js",
@@ -18,6 +18,7 @@
   "dependencies": {
     "@clack/prompts": "^0.9.1",
     "commander": "^12.1.0",
+    "mqtt": "^5.16.1",
     "open": "^10.1.0",
     "picocolors": "^1.1.1",
     "ws": "^8.22.0"

package/src/local-printer-executor.js

@@ -1,3 +1,5 @@
+import mqtt from 'mqtt';
+
 export async function executeLocalPrinterAction({ action, printerId, connectionConfig, payload }) {
   if (!connectionConfig) {
     throw new Error('Configuração de conexão da impressora não foi fornecida pelo servidor');
@@ -8,14 +10,27 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
   const apiKey = connectionConfig.apiKey;
   const headers = apiKey ? { 'X-Api-Key': apiKey } : {};
 
+  // =====================================================
   // 1. Verificação de Conexão
+  // =====================================================
   if (action === 'connect') {
+    // KLIPPER / MOONRAKER
     if (type === 'klipper') {
-      const infoRes = await fetch(`${baseUrl}/server/info`, { headers, signal: AbortSignal.timeout(8000) });
+      let infoRes;
+      try {
+        infoRes = await fetch(`${baseUrl}/server/info`, {
+          headers,
+          signal: AbortSignal.timeout(8000),
+        });
+      } catch (err) {
+        throw new Error(`Não foi possível conectar ao Klipper em ${baseUrl} (${err.code || err.message}). Verifique se a impressora está ligada e o IP/porta estão corretos.`);
+      }
+
       if (!infoRes.ok) {
-        throw new Error(`Moonraker retornou HTTP ${infoRes.status}: ${infoRes.statusText}`);
+        throw new Error(`Klipper em ${baseUrl} respondeu com erro HTTP ${infoRes.status}`);
       }
-      const info = await infoRes.json();
+
+      const info = await infoRes.json().catch(() => ({}));
       const klippyState = info?.result?.klippy_state || 'ready';
 
       let status = klippyState === 'ready' ? 'IDLE' : 'ERROR';
@@ -54,6 +69,82 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
       };
     }
 
+    // BAMBU LAB (LAN MQTT)
+    if (type === 'bambu') {
+      const host = connectionConfig.host;
+      const port = connectionConfig.mqttPort || 8883;
+      const username = connectionConfig.username || 'bblp';
+      const password = connectionConfig.accessCode;
+      const serialNumber = connectionConfig.serialNumber;
+
+      if (!host || !password || !serialNumber) {
+        throw new Error('Configuração da Bambu incompleta: host, accessCode e serialNumber são obrigatórios');
+      }
+
+      return new Promise((resolve, reject) => {
+        let isDone = false;
+        const timer = setTimeout(() => {
+          if (isDone) return;
+          isDone = true;
+          try { client.end(true); } catch {}
+          reject(new Error(`Tempo limite esgotado tentando conectar ao MQTT da Bambu em ${host}:${port}`));
+        }, 9000);
+
+        const client = mqtt.connect(`mqtts://${host}:${port}`, {
+          clientId: `foundry_edge_${Date.now()}`,
+          username,
+          password,
+          rejectUnauthorized: false,
+          connectTimeout: 8000,
+          clean: true,
+        });
+
+        client.on('connect', () => {
+          client.subscribe(`device/${serialNumber}/report`, () => {
+            client.publish(
+              `device/${serialNumber}/request`,
+              JSON.stringify({ pushing: { sequence_id: '1', command: 'pushall', version: 1, push_target: 1 } })
+            );
+          });
+        });
+
+        client.on('message', (_topic, payloadBuffer) => {
+          if (isDone) return;
+          try {
+            const data = JSON.parse(payloadBuffer.toString('utf8'));
+            if (data.print) {
+              isDone = true;
+              clearTimeout(timer);
+              client.end(true);
+              const state = String(data.print.gcode_state || 'IDLE').toUpperCase();
+              const percent = Number(data.print.mc_percent || 0);
+              resolve({
+                online: true,
+                status: state === 'RUNNING' || state === 'PREPARE' ? 'PRINTING' : (state === 'PAUSE' ? 'PAUSED' : 'IDLE'),
+                message: `Bambu LAN conectada (${state})`,
+                progress: percent,
+                temperatures: {
+                  hotend: data.print.nozzle_temper,
+                  hotendTarget: data.print.nozzle_target_temper,
+                  bed: data.print.bed_temper,
+                  bedTarget: data.print.bed_target_temper,
+                },
+              });
+            }
+          } catch {}
+        });
+
+        client.on('error', (err) => {
+          if (isDone) return;
+          isDone = true;
+          clearTimeout(timer);
+          try { client.end(true); } catch {}
+          reject(new Error(`Falha de conexão com a Bambu em ${host}: ${err.message}`));
+        });
+      });
+    }
+
+    // OCTOPRINT
     if (type === 'octoprint') {
       const verRes = await fetch(`${baseUrl}/api/version`, { headers, signal: AbortSignal.timeout(8000) });
       if (!verRes.ok) {
@@ -69,7 +160,9 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
     throw new Error(`Protocolo de impressora "${type}" não suportado para conexão direta`);
   }
 
+  // =====================================================
   // 2. Snapshot de Câmera Local
+  // =====================================================
   if (action === 'camera/snapshot') {
     const camUrl = connectionConfig.cameraSnapshotUrl || connectionConfig.cameraUrl || `${baseUrl}/webcam/?action=snapshot`;
     const camRes = await fetch(camUrl, { signal: AbortSignal.timeout(10000) });
@@ -80,7 +173,9 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
     return { base64: Buffer.from(buf).toString('base64') };
   }
 
+  // =====================================================
   // 3. Controle da Impressora (Pausa, Emergência, Motores, etc.)
+  // =====================================================
   if (action === 'control') {
     const cmd = payload?.command;
     if (type === 'klipper') {
@@ -99,7 +194,9 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
     }
   }
 
+  // =====================================================
   // 4. Comandos de Trabalho (Job Pause / Resume / Cancel)
+  // =====================================================
   if (action.startsWith('job/')) {
     const jobCmd = action.replace('job/', '');
     if (type === 'klipper') {

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,21 +1,43 @@
+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';
+import { edgeTunnelClient } from './tunnel-client.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}`;
 
+  // Garante que o túnel de comandos com a Nuvem esteja ativo
+  if (config?.apiKey && config?.serverUrl) {
+    edgeTunnelClient.start();
+  }
+
   console.clear();
 
   p.intro(
     `${pc.bold(pc.cyan('======================================================'))}\n` +
     `  ${pc.bold(pc.yellow(`Project Foundry Interface (${version})`))}\n` +
     `  🚀 Server: ${pc.green(localUrl)}\n` +
+    `  🌐 Nuvem: ${edgeTunnelClient.isConnected() ? pc.green('Conectado (Túnel Ativo)') : pc.cyan('Túnel Iniciado')}\n` +
     `  💾 Storage: ${pc.cyan(config?.storagePath || 'Padrão')}\n` +
     `${pc.bold(pc.cyan('======================================================'))}`
   );
@@ -33,7 +55,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 +65,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 +122,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);
+      }
     }
   }
 }

package/src/tunnel-client.js

@@ -8,6 +8,11 @@ export class EdgeTunnelClient {
     this.pingTimer = null;
     this.reconnectTimer = null;
     this.isStopping = false;
+    this.status = 'DISCONNECTED';
+  }
+
+  isConnected() {
+    return Boolean(this.ws && this.ws.readyState === WebSocket.OPEN);
   }
 
   start() {
@@ -16,12 +21,15 @@ export class EdgeTunnelClient {
       return;
     }
 
+    if (this.isConnected()) return;
+
     this.isStopping = false;
     this.connect();
   }
 
   stop() {
     this.isStopping = true;
+    this.status = 'DISCONNECTED';
     if (this.pingTimer) clearInterval(this.pingTimer);
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
     if (this.ws) {
@@ -50,6 +58,7 @@ export class EdgeTunnelClient {
       });
 
       this.ws.on('open', () => {
+        this.status = 'CONNECTED';
         // Envia PING a cada 25 segundos
         if (this.pingTimer) clearInterval(this.pingTimer);
         this.pingTimer = setInterval(() => {
@@ -69,15 +78,18 @@ export class EdgeTunnelClient {
       });
 
       this.ws.on('close', () => {
+        this.status = 'DISCONNECTED';
         if (this.pingTimer) clearInterval(this.pingTimer);
         this.scheduleReconnect();
       });
 
       this.ws.on('error', () => {
+        this.status = 'DISCONNECTED';
         if (this.pingTimer) clearInterval(this.pingTimer);
         this.scheduleReconnect();
       });
     } catch {
+      this.status = 'DISCONNECTED';
       this.scheduleReconnect();
     }
   }