project-foundry 1.0.9 → 1.1.0

package/package.json

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

package/src/daemon.js

@@ -90,7 +90,27 @@ export function startDaemon() {
             },
           }, (cloudRes) => {
             res.writeHead(cloudRes.statusCode, cloudRes.headers);
-            cloudRes.pipe(res);
+            let responseBody = '';
+            cloudRes.on('data', (chunk) => {
+              res.write(chunk);
+              responseBody += chunk.toString();
+            });
+            cloudRes.on('end', () => {
+              res.end();
+              try {
+                const parsed = JSON.parse(responseBody);
+                const originalName = parsed?.files?.local?.name;
+                const fileId = parsed?.flowSystem3D?.fileId;
+                if (originalName) {
+                  fs.copyFileSync(tempFilePath, path.join(storageDir, originalName));
+                }
+                if (fileId) {
+                  const ext = (originalName && originalName.endsWith('.3mf')) ? '.3mf' : '.gcode';
+                  fs.copyFileSync(tempFilePath, path.join(storageDir, `${fileId}${ext}`));
+                }
+                fs.unlinkSync(tempFilePath);
+              } catch {}
+            });
           });
 
           cloudReq.on('error', (err) => {

package/src/local-printer-executor.js

@@ -1,8 +1,82 @@
 import mqtt from 'mqtt';
 import { connect as connectTls } from 'node:tls';
 import { Client as FtpClient } from 'basic-ftp';
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import https from 'node:https';
 import { readConfig } from './config.js';
 
+function downloadFileFromCloud({ serverUrl, fileId, pat }) {
+  return new Promise((resolve, reject) => {
+    const rawUrl = `${serverUrl}/api/v1/files/${fileId}/download`;
+    let parsed;
+    try {
+      parsed = new URL(rawUrl);
+    } catch {
+      return reject(new Error(`URL inválida para download: ${rawUrl}`));
+    }
+    const isHttps = parsed.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    const req = transport.request(parsed, {
+      method: 'GET',
+      family: 4,
+      rejectUnauthorized: false,
+      headers: pat ? { 'Authorization': `Bearer ${pat}` } : {},
+      timeout: 60000,
+    }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return resolve(downloadFileFromCloud({ serverUrl: res.headers.location.replace(/\/api\/v1\/files\/.*$/, ''), fileId, pat }));
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Nuvem retornou HTTP ${res.statusCode} ao baixar arquivo`));
+      }
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+
+    req.on('error', (err) => {
+      // Fallback: se DNS falhar para foundry.projectcore.site, tentar direto pelo IP da VPS
+      if (parsed.hostname === 'foundry.projectcore.site' && isHttps) {
+        const ipReq = https.request({
+          hostname: '164.152.35.52',
+          port: 443,
+          path: parsed.pathname + parsed.search,
+          method: 'GET',
+          family: 4,
+          rejectUnauthorized: false,
+          servername: 'foundry.projectcore.site',
+          headers: {
+            'Host': 'foundry.projectcore.site',
+            ...(pat ? { 'Authorization': `Bearer ${pat}` } : {}),
+          },
+          timeout: 60000,
+        }, (ipRes) => {
+          if (ipRes.statusCode !== 200) {
+            return reject(new Error(`Nuvem (via IP) retornou HTTP ${ipRes.statusCode} ao baixar arquivo`));
+          }
+          const chunks = [];
+          ipRes.on('data', chunk => chunks.push(chunk));
+          ipRes.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+        ipReq.on('error', (ipErr) => reject(new Error(`Falha ao baixar arquivo da nuvem (DNS e IP): ${ipErr.message}`)));
+        ipReq.on('timeout', () => { ipReq.destroy(); reject(new Error('Timeout de 60s ao baixar arquivo via IP')); });
+        ipReq.end();
+        return;
+      }
+      reject(new Error(`Falha ao baixar arquivo da nuvem: ${err.message}`));
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Timeout de 60s ao baixar arquivo da nuvem'));
+    });
+    req.end();
+  });
+}
+
 // Cache em memória das últimas telemetrias da Bambu (serialNumber -> { timestamp, print })
 const latestBambuReports = new Map();
 
@@ -558,34 +632,102 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
   // =====================================================
   if (action === 'job/start') {
     const cfg = readConfig();
-    const serverUrl = (cfg?.serverUrl || '').replace(/\/$/, '');
+    const serverUrl = (cfg?.serverUrl || 'https://foundry.projectcore.site').replace(/\/$/, '');
     const pat = cfg?.apiKey;
+    const storageDir = cfg?.storagePath || path.join(process.cwd(), 'storage');
+
+    const originalName = payload?.originalName || payload?.filename || 'print.gcode';
+    const remoteName = payload?.remoteName || originalName;
+    const fileId = payload?.fileId;
+
+    let fileBuffer = null;
 
-    if (!payload?.fileId) {
-      throw new Error('ID do arquivo não fornecido para início do trabalho');
+    // A. Buffer recebido inline no WebSocket (Base64)
+    if (payload?.fileBase64) {
+      try {
+        fileBuffer = Buffer.from(payload.fileBase64, 'base64');
+        try {
+          if (!fs.existsSync(storageDir)) fs.mkdirSync(storageDir, { recursive: true });
+          fs.writeFileSync(path.join(storageDir, remoteName), fileBuffer);
+        } catch {}
+      } catch {}
     }
 
-    // 1. Baixa o arquivo da nuvem usando o PAT
-    const downloadUrl = `${serverUrl}/api/v1/files/${payload.fileId}/download`;
-    let fileRes;
-    try {
-      fileRes = await fetch(downloadUrl, {
-        headers: { 'Authorization': `Bearer ${pat}` },
-        signal: AbortSignal.timeout(60000),
-      });
-    } catch (err) {
-      throw new Error(`Falha ao baixar arquivo da nuvem para o nó local: ${err.message}`);
+    // B. Se não veio inline, buscar no HD local do Edge Node
+    if (!fileBuffer && fs.existsSync(storageDir)) {
+      const candidates = [
+        path.join(storageDir, remoteName),
+        path.join(storageDir, originalName),
+        fileId ? path.join(storageDir, `${fileId}.gcode`) : null,
+        fileId ? path.join(storageDir, `${fileId}.3mf`) : null,
+      ].filter(Boolean);
+
+      for (const cand of candidates) {
+        if (fs.existsSync(cand)) {
+          try {
+            fileBuffer = fs.readFileSync(cand);
+            break;
+          } catch {}
+        }
+      }
     }
 
-    if (!fileRes.ok) {
-      throw new Error(`Nuvem retornou HTTP ${fileRes.status} ao baixar arquivo ${payload.fileId}`);
+    // C. Se for Klipper e o arquivo já estiver na máquina, iniciar imediatamente
+    if (!fileBuffer && type === 'klipper') {
+      try {
+        const listRes = await fetch(`${baseUrl}/server/files/list?root=gcodes`, {
+          headers,
+          signal: AbortSignal.timeout(6000),
+        });
+        if (listRes.ok) {
+          const filesData = await listRes.json();
+          const items = Array.isArray(filesData?.result) ? filesData.result : [];
+          const matched = items.find(item =>
+            item.filename === remoteName ||
+            item.filename === originalName ||
+            item.filename === path.basename(remoteName)
+          );
+          if (matched) {
+            const startRes = await fetch(`${baseUrl}/printer/print/start?filename=${encodeURIComponent(matched.filename)}`, {
+              method: 'POST',
+              headers,
+              signal: AbortSignal.timeout(10000),
+            });
+            if (startRes.ok) {
+              return {
+                online: true,
+                status: 'PRINTING',
+                message: `Impressão iniciada via Klipper (${matched.filename})`,
+                filename: matched.filename,
+              };
+            }
+          }
+        }
+      } catch {}
     }
 
-    const fileBuffer = Buffer.from(await fileRes.arrayBuffer());
+    // D. Se ainda não tiver o arquivo localmente, baixar da nuvem com resiliência total
+    if (!fileBuffer && fileId) {
+      try {
+        fileBuffer = await downloadFileFromCloud({ serverUrl, fileId, pat });
+        if (fileBuffer) {
+          try {
+            if (!fs.existsSync(storageDir)) fs.mkdirSync(storageDir, { recursive: true });
+            fs.writeFileSync(path.join(storageDir, remoteName), fileBuffer);
+          } catch {}
+        }
+      } catch (err) {
+        if (type !== 'bambu') {
+          throw err;
+        }
+      }
+    }
 
-    // KLIPPER / MOONRAKER (ex: K1 Max)
+    // KLIPPER / MOONRAKER (K1, K1 Max, Ender 3, Voron, etc.)
     if (type === 'klipper') {
-      const remoteName = payload.remoteName || payload.originalName || 'print.gcode';
+      if (!fileBuffer) {
+        throw new Error(`Arquivo "${originalName}" não encontrado localmente nem disponível para download`);
+      }
       const form = new FormData();
       form.append('file', new Blob([fileBuffer], { type: 'text/x-gcode' }), remoteName);
       form.append('root', 'gcodes');
@@ -600,7 +742,7 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
           signal: AbortSignal.timeout(120000),
         });
       } catch (err) {
-        throw new Error(`Não foi possível enviar o arquivo para a K1 Max em ${baseUrl}: ${err.message}`);
+        throw new Error(`Não foi possível enviar o arquivo para Klipper em ${baseUrl}: ${err.message}`);
       }
 
       if (!uploadRes.ok) {
@@ -616,36 +758,37 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
       };
     }
 
-    // BAMBU LAB (P1S, etc.)
+    // BAMBU LAB (P1S, P1P, X1 Carbon, X1E, A1, A1 mini)
     if (type === 'bambu') {
       const host = connectionConfig.host;
       const port = connectionConfig.ftpPort || 990;
       const accessCode = connectionConfig.accessCode;
       const serialNumber = connectionConfig.serialNumber;
-      const remoteName = payload.remoteName || payload.originalName || 'print.gcode.3mf';
 
       if (!host || !accessCode || !serialNumber) {
         throw new Error('Configuração da Bambu incompleta para envio');
       }
 
-      // Envia via FTPS
-      const ftpClient = new FtpClient(60000);
-      try {
-        await ftpClient.access({
-          host,
-          port,
-          user: 'bblp',
-          password: accessCode,
-          secure: 'implicit',
-          secureOptions: { rejectUnauthorized: false },
-        });
-        await ftpClient.ensureDir('/');
-        const { Readable } = await import('node:stream');
-        await ftpClient.uploadFrom(Readable.from(fileBuffer), remoteName);
-      } catch (err) {
-        throw new Error(`Falha no FTPS local da Bambu: ${err.message}`);
-      } finally {
-        ftpClient.close();
+      // Se temos o buffer, tenta enviar via FTPS
+      if (fileBuffer) {
+        const ftpClient = new FtpClient(60000);
+        try {
+          await ftpClient.access({
+            host,
+            port,
+            user: 'bblp',
+            password: accessCode,
+            secure: 'implicit',
+            secureOptions: { rejectUnauthorized: false },
+          });
+          await ftpClient.ensureDir('/');
+          const { Readable } = await import('node:stream');
+          await ftpClient.uploadFrom(Readable.from(fileBuffer), remoteName);
+        } catch (err) {
+          // Se falhar FTPS, prossegue com MQTT caso o arquivo já exista no cartão
+        } finally {
+          ftpClient.close();
+        }
       }
 
       // Dispara comando MQTT
@@ -712,6 +855,17 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
       });
     }
 
+    // OCTOPRINT / PRUSALINK / OUTROS
+    if (type === 'octoprint') {
+      if (!fileBuffer) throw new Error('Arquivo não disponível para envio ao OctoPrint');
+      const form = new FormData();
+      form.append('file', new Blob([fileBuffer], { type: 'text/x-gcode' }), remoteName);
+      form.append('select', 'true');
+      form.append('print', 'true');
+      const res = await fetch(`${baseUrl}/api/files/local`, { method: 'POST', headers, body: form });
+      return { online: true, status: 'PRINTING', message: 'Iniciado via OctoPrint', filename: remoteName };
+    }
+
     throw new Error(`Protocolo "${type}" não suporta envio automático de arquivos`);
   }