project-foundry 1.0.8 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-foundry",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Project Foundry CLI & Local Node Daemon Manager",
   "bin": {
     "project-foundry": "bin/foundry.js",
@@ -17,6 +17,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.9.1",
+    "basic-ftp": "^6.2.4",
     "commander": "^12.1.0",
     "mqtt": "^5.16.1",
     "open": "^10.1.0",

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,5 +1,81 @@
 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();
@@ -551,5 +627,247 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
     });
   }
 
+  // =====================================================
+  // 6. Início e Envio de Trabalho (Job Start via LAN)
+  // =====================================================
+  if (action === 'job/start') {
+    const cfg = readConfig();
+    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;
+
+    // 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 {}
+    }
+
+    // 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 {}
+        }
+      }
+    }
+
+    // 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 {}
+    }
+
+    // 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 (K1, K1 Max, Ender 3, Voron, etc.)
+    if (type === 'klipper') {
+      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');
+      form.append('print', 'true');
+
+      let uploadRes;
+      try {
+        uploadRes = await fetch(`${baseUrl}/server/files/upload`, {
+          method: 'POST',
+          headers,
+          body: form,
+          signal: AbortSignal.timeout(120000),
+        });
+      } catch (err) {
+        throw new Error(`Não foi possível enviar o arquivo para Klipper em ${baseUrl}: ${err.message}`);
+      }
+
+      if (!uploadRes.ok) {
+        const detail = await uploadRes.text().catch(() => '');
+        throw new Error(`Klipper recusou o início (${uploadRes.status}): ${detail.slice(0, 200)}`);
+      }
+
+      return {
+        online: true,
+        status: 'PRINTING',
+        message: 'Impressão iniciada com sucesso via Klipper',
+        filename: remoteName,
+      };
+    }
+
+    // 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;
+
+      if (!host || !accessCode || !serialNumber) {
+        throw new Error('Configuração da Bambu incompleta para envio');
+      }
+
+      // 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
+      return new Promise((resolve, reject) => {
+        const client = mqtt.connect(`mqtts://${host}:${connectionConfig.mqttPort || 8883}`, {
+          username: connectionConfig.username || 'bblp',
+          password: accessCode,
+          rejectUnauthorized: false,
+          connectTimeout: 8000,
+          clean: true,
+        });
+
+        const timer = setTimeout(() => {
+          try { client.end(true); } catch {}
+          reject(new Error('Timeout aguardando confirmação MQTT da Bambu'));
+        }, 12000);
+
+        const isP1orA1 = Boolean(
+          serialNumber.startsWith('01P') || serialNumber.startsWith('030') || serialNumber.startsWith('039')
+        );
+
+        const printCmd = {
+          print: {
+            sequence_id: String(Date.now()),
+            command: 'project_file',
+            param: `Metadata/plate_${payload.plateNumber || 1}.gcode`,
+            project_id: '0',
+            profile_id: '0',
+            task_id: '0',
+            subtask_id: '0',
+            subtask_name: remoteName,
+            file: remoteName,
+            url: `ftp:///${remoteName}`,
+            md5: '',
+            timelapse: Boolean(payload.printSettings?.timelapse),
+            bed_type: isP1orA1 ? 'textured_plate' : 'auto',
+            bed_levelling: payload.printSettings?.bedLeveling !== false,
+            flow_cali: isP1orA1 ? false : Boolean(payload.printSettings?.flowCalibration),
+            vibration_cali: payload.printSettings?.vibrationCalibration !== false,
+            layer_inspect: !isP1orA1,
+            use_ams: Boolean(payload.printSettings?.useAms),
+            ams_mapping: Array.isArray(payload.printSettings?.amsMapping) ? payload.printSettings.amsMapping : [0],
+          },
+        };
+
+        client.on('connect', () => {
+          client.publish(`device/${serialNumber}/request`, JSON.stringify(printCmd), () => {
+            clearTimeout(timer);
+            client.end(true);
+            resolve({
+              online: true,
+              status: 'PRINTING',
+              message: 'Impressão iniciada via Bambu LAN',
+              filename: remoteName,
+            });
+          });
+        });
+
+        client.on('error', (err) => {
+          clearTimeout(timer);
+          try { client.end(true); } catch {}
+          reject(err);
+        });
+      });
+    }
+
+    // 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`);
+  }
+
   throw new Error(`Ação "${action}" não suportada`);
 }