project-foundry 1.0.3 → 1.0.5

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.3",
+  "version": "1.0.5",
   "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,72 @@
+import mqtt from 'mqtt';
+import { connect as connectTls } from 'node:tls';
+
+function buildBambuCameraAuthPacket(accessCode) {
+  const packet = Buffer.alloc(80);
+  packet.writeUInt32LE(0x40, 0);
+  packet.writeUInt32LE(0x3000, 4);
+  packet.write('bblp', 16, 31, 'utf8');
+  packet.write(accessCode, 48, 31, 'utf8');
+  return packet;
+}
+
+function captureBambuJpegTls(connection) {
+  const host = (connection.host || '').trim().replace(/^\w+:\/\//, '').replace(/\/$/, '').split('/')[0];
+  const accessCode = connection.accessCode;
+  if (!host || !accessCode) throw new Error('Câmera Bambu requer IP e código de acesso LAN');
+
+  return new Promise((resolve, reject) => {
+    let pending = Buffer.alloc(0);
+    let expectedSize;
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      finish(new Error('A câmera Bambu não respondeu dentro do tempo limite (12s)'));
+    }, 12000);
+
+    const socket = connectTls({ host, port: 6000, rejectUnauthorized: false });
+
+    const finish = (error, frame) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try { socket.destroy(); } catch {}
+      if (error) reject(error);
+      else if (frame) resolve(frame);
+      else reject(new Error('A câmera Bambu encerrou sem entregar imagem'));
+    };
+
+    socket.once('secureConnect', () => {
+      try {
+        socket.write(buildBambuCameraAuthPacket(accessCode));
+      } catch (err) {
+        finish(err);
+      }
+    });
+
+    socket.on('data', (chunk) => {
+      pending = Buffer.concat([pending, chunk]);
+      if (expectedSize === undefined && pending.length >= 16) {
+        expectedSize = pending.readUInt32LE(0);
+        if (expectedSize <= 0 || expectedSize > 12 * 1024 * 1024) {
+          finish(new Error('A câmera Bambu retornou um tamanho de quadro inválido'));
+          return;
+        }
+      }
+      if (expectedSize !== undefined && pending.length >= expectedSize + 16) {
+        const frame = pending.subarray(16, expectedSize + 16);
+        if (frame[0] !== 0xff || frame[1] !== 0xd8) {
+          finish(new Error('A câmera Bambu não retornou uma imagem JPEG válida'));
+          return;
+        }
+        finish(null, frame);
+      }
+    });
+
+    socket.on('error', (err) => finish(err));
+  });
+}
+
 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 +77,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
+  // =====================================================
+  // 1. Verificação de Conexão e Telemetria
+  // =====================================================
   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 +136,84 @@ 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);
+              const isPrinting = state === 'RUNNING' || state === 'PREPARE';
+              resolve({
+                online: true,
+                status: isPrinting ? '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,
+                  chamber: data.print.chamber_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,8 +229,15 @@ 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
+  // =====================================================
+  // 2. Snapshot de Câmera Local (Bambu / Klipper / OctoPrint)
+  // =====================================================
   if (action === 'camera/snapshot') {
+    if (type === 'bambu') {
+      const jpegBuffer = await captureBambuJpegTls(connectionConfig);
+      return { base64: Buffer.from(jpegBuffer).toString('base64') };
+    }
+
     const camUrl = connectionConfig.cameraSnapshotUrl || connectionConfig.cameraUrl || `${baseUrl}/webcam/?action=snapshot`;
     const camRes = await fetch(camUrl, { signal: AbortSignal.timeout(10000) });
     if (!camRes.ok) {
@@ -80,7 +247,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 +268,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/tui.js

@@ -7,6 +7,7 @@ import pc from 'picocolors';
 import open from 'open';
 import { readConfig, updateStoragePath } from './config.js';
 import { isServerHealthy, stopRunningDaemon, restartAutostartService } from './service-manager.js';
+import { edgeTunnelClient } from './tunnel-client.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -25,12 +26,18 @@ export async function runInteractiveTui() {
   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('======================================================'))}`
   );

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();
     }
   }