project-foundry 1.0.5 → 1.0.7

package/package.json

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

package/src/local-printer-executor.js

@@ -1,6 +1,9 @@
 import mqtt from 'mqtt';
 import { connect as connectTls } from 'node:tls';
 
+// Cache em memória das últimas telemetrias da Bambu (serialNumber -> { timestamp, print })
+const latestBambuReports = new Map();
+
 function buildBambuCameraAuthPacket(accessCode) {
   const packet = Buffer.alloc(80);
   packet.writeUInt32LE(0x40, 0);
@@ -67,6 +70,45 @@ function captureBambuJpegTls(connection) {
   });
 }
 
+function bambuColor(value) {
+  if (typeof value !== 'string') return undefined;
+  const normalized = value.replace(/^#/, '').slice(0, 6);
+  return /^[0-9a-f]{6}$/i.test(normalized) ? `#${normalized.toUpperCase()}` : undefined;
+}
+
+function parseBambuAmsState(print) {
+  const ams = print?.ams || {};
+  const units = Array.isArray(ams.ams) ? ams.ams : [];
+  const slots = units.flatMap((unit, unitIndex) => {
+    const amsId = (unit.id !== undefined && !Number.isNaN(Number(unit.id))) ? Number(unit.id) : unitIndex;
+    const trays = Array.isArray(unit.tray) ? unit.tray : [];
+    return trays.map((tray, slotIndex) => {
+      const slotId = (tray.id !== undefined && !Number.isNaN(Number(tray.id))) ? Number(tray.id) : slotIndex;
+      const trayId = amsId * 4 + slotId;
+      const filamentType = typeof tray.tray_type === 'string' && tray.tray_type ? tray.tray_type : undefined;
+      const hasMetadata = Boolean(filamentType || tray.tray_info_idx || tray.setting_id);
+      const remaining = Number(tray.remain);
+      return {
+        trayId,
+        amsId,
+        slotId,
+        label: `AMS ${String.fromCharCode(65 + amsId)} · slot ${slotId + 1}`,
+        filamentType,
+        color: bambuColor(tray.tray_color),
+        remainingPercent: Number.isFinite(remaining) && remaining >= 0 ? remaining : undefined,
+        empty: !hasMetadata,
+      };
+    });
+  });
+  const currentTrayId = Number(ams.tray_now);
+  return {
+    available: slots.length > 0,
+    currentTrayId: Number.isFinite(currentTrayId) && currentTrayId >= 0 && currentTrayId < 255 ? currentTrayId : undefined,
+    slots,
+    readAt: new Date().toISOString(),
+  };
+}
+
 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');
@@ -103,20 +145,40 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
       let status = klippyState === 'ready' ? 'IDLE' : 'ERROR';
       let message = `Klipper: ${klippyState}`;
       let temperatures = {};
+      let progress = 0;
+      let currentLayer = 0;
+      let totalLayers = 0;
+      let filename;
+      let elapsedSeconds = 0;
 
       try {
         const telRes = await fetch(
-          `${baseUrl}/printer/objects/query?print_stats&extruder&heater_bed`,
-          { headers, signal: AbortSignal.timeout(5000) }
+          `${baseUrl}/printer/objects/query?print_stats&display_status&virtual_sdcard&extruder&heater_bed`,
+          { headers, signal: AbortSignal.timeout(6000) }
         );
         if (telRes.ok) {
           const tel = await telRes.json();
-          const stats = tel?.result?.status?.print_stats || {};
-          const ext = tel?.result?.status?.extruder || {};
-          const bed = tel?.result?.status?.heater_bed || {};
-          const st = String(stats.state || '').toLowerCase();
+          const s = tel?.result?.status || {};
+          const printStats = s.print_stats || {};
+          const display = s.display_status || {};
+          const virtualSd = s.virtual_sdcard || {};
+          const ext = s.extruder || {};
+          const bed = s.heater_bed || {};
+
+          const st = String(printStats.state || '').toLowerCase();
           if (st === 'printing') status = 'PRINTING';
           else if (st === 'paused') status = 'PAUSED';
+          else if (st === 'complete') status = 'IDLE';
+          else if (st === 'error') status = 'ERROR';
+
+          const dispProg = Number(display.progress || 0);
+          const sdProg = Number(virtualSd.progress || 0);
+          progress = Math.round(Math.max(dispProg, sdProg) * 100);
+
+          currentLayer = Number(virtualSd.layer || printStats?.info?.current_layer || 0);
+          totalLayers = Number(virtualSd.layer_count || printStats?.info?.total_layer || 0);
+          filename = printStats.filename || undefined;
+          elapsedSeconds = Number(printStats.print_duration || printStats.total_duration || 0);
 
           temperatures = {
             hotend: ext.temperature,
@@ -124,7 +186,7 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
             bed: bed.temperature,
             bedTarget: bed.target,
           };
-          if (stats.message) message = stats.message;
+          if (printStats.message) message = printStats.message;
         }
       } catch {}
 
@@ -132,6 +194,11 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
         online: true,
         status,
         message,
+        progress,
+        currentLayer,
+        totalLayers,
+        filename,
+        elapsedSeconds,
         temperatures,
       };
     }
@@ -180,23 +247,49 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
           try {
             const data = JSON.parse(payloadBuffer.toString('utf8'));
             if (data.print) {
+              latestBambuReports.set(serialNumber, {
+                timestamp: Date.now(),
+                print: 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';
+              const isFinished = state === 'FINISH' || (state === 'IDLE' && percent === 100);
+              const isPrinting = (state === 'RUNNING' || state === 'PREPARE') && !isFinished;
+              const isPaused = state === 'PAUSE';
+
+              const filename =
+                typeof data.print.subtask_name === 'string' && data.print.subtask_name.trim()
+                  ? data.print.subtask_name.trim()
+                  : typeof data.print.gcode_file === 'string' && data.print.gcode_file.trim()
+                  ? data.print.gcode_file.trim()
+                  : undefined;
+
+              const remainingMins = Number(data.print.mc_remaining_time);
+              const remainingSeconds = Number.isFinite(remainingMins) ? Math.max(0, remainingMins * 60) : undefined;
+
               resolve({
                 online: true,
-                status: isPrinting ? 'PRINTING' : (state === 'PAUSE' ? 'PAUSED' : 'IDLE'),
-                message: `Bambu LAN conectada (${state})`,
+                status: isPrinting ? 'PRINTING' : (isPaused ? 'PAUSED' : 'IDLE'),
+                message: isFinished
+                  ? 'Impressão concluída com sucesso'
+                  : `Bambu LAN conectada (${state})`,
                 progress: percent,
+                currentLayer: Number(data.print.layer_num || 0),
+                totalLayers: Number(data.print.total_layer_num || 0),
+                filename,
+                remainingSeconds,
+                jobFinished: isFinished,
                 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,
+                  hotend: Number(data.print.nozzle_temper || 0),
+                  hotendTarget: Number(data.print.nozzle_target_temper || 0),
+                  bed: Number(data.print.bed_temper || 0),
+                  bedTarget: Number(data.print.bed_target_temper || 0),
+                  chamber: Number(data.print.chamber_temper || 0),
                 },
               });
             }
@@ -266,6 +359,45 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
       const res = await fetch(`${baseUrl}${endpoint}`, { method: 'POST', headers, signal: AbortSignal.timeout(8000) });
       return { success: res.ok };
     }
+
+    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;
+      const bCmd = cmd === 'pause' ? 'pause' : cmd === 'resume' ? 'resume' : cmd === 'cancel' ? 'stop' : null;
+
+      if (!bCmd) throw new Error(`Comando "${cmd}" não suportado para Bambu`);
+
+      return new Promise((resolve, reject) => {
+        const client = mqtt.connect(`mqtts://${host}:${port}`, {
+          username, password, rejectUnauthorized: false, connectTimeout: 6000, clean: true,
+        });
+        const timer = setTimeout(() => {
+          try { client.end(true); } catch {}
+          reject(new Error(`Timeout ao enviar comando "${cmd}" para a Bambu`));
+        }, 7000);
+
+        client.on('connect', () => {
+          client.publish(
+            `device/${serialNumber}/request`,
+            JSON.stringify({ print: { sequence_id: String(Date.now()), command: bCmd, param: '' } }),
+            () => {
+              clearTimeout(timer);
+              client.end(true);
+              resolve({ success: true });
+            }
+          );
+        });
+
+        client.on('error', (err) => {
+          clearTimeout(timer);
+          try { client.end(true); } catch {}
+          reject(err);
+        });
+      });
+    }
   }
 
   // =====================================================
@@ -285,6 +417,138 @@ export async function executeLocalPrinterAction({ action, printerId, connectionC
         return { success: res.ok };
       }
     }
+
+    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;
+      const bCmd = jobCmd === 'pause' ? 'pause' : jobCmd === 'resume' ? 'resume' : jobCmd === 'cancel' ? 'stop' : null;
+
+      if (bCmd) {
+        return new Promise((resolve, reject) => {
+          const client = mqtt.connect(`mqtts://${host}:${port}`, {
+            username, password, rejectUnauthorized: false, connectTimeout: 6000, clean: true,
+          });
+          const timer = setTimeout(() => {
+            try { client.end(true); } catch {}
+            reject(new Error(`Timeout ao enviar comando "${jobCmd}" para a Bambu`));
+          }, 7000);
+
+          client.on('connect', () => {
+            client.publish(
+              `device/${serialNumber}/request`,
+              JSON.stringify({ print: { sequence_id: String(Date.now()), command: bCmd, param: '' } }),
+              () => {
+                clearTimeout(timer);
+                client.end(true);
+                resolve({ success: true });
+              }
+            );
+          });
+
+          client.on('error', (err) => {
+            clearTimeout(timer);
+            try { client.end(true); } catch {}
+            reject(err);
+          });
+        });
+      }
+    }
+  }
+
+  // =====================================================
+  // 5. Bambu AMS State (Leitura de slots e filamentos)
+  // =====================================================
+  if (action === 'ams') {
+    if (type !== 'bambu') {
+      return {
+        available: false,
+        slots: [],
+        readAt: new Date().toISOString(),
+      };
+    }
+
+    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');
+    }
+
+    // Cache recente (< 30s)
+    const cached = latestBambuReports.get(serialNumber);
+    if (cached && (Date.now() - cached.timestamp < 30000) && cached.print?.ams) {
+      return parseBambuAmsState(cached.print);
+    }
+
+    // Consulta MQTT na LAN local
+    return new Promise((resolve) => {
+      let isDone = false;
+      const timer = setTimeout(() => {
+        if (isDone) return;
+        isDone = true;
+        try { client.end(true); } catch {}
+        if (cached?.print?.ams) {
+          resolve(parseBambuAmsState(cached.print));
+        } else {
+          resolve({ available: false, slots: [], readAt: new Date().toISOString() });
+        }
+      }, 7000);
+
+      const client = mqtt.connect(`mqtts://${host}:${port}`, {
+        clientId: `foundry_edge_ams_${Date.now()}`,
+        username,
+        password,
+        rejectUnauthorized: false,
+        connectTimeout: 6000,
+        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) {
+            latestBambuReports.set(serialNumber, {
+              timestamp: Date.now(),
+              print: data.print,
+            });
+            if (data.print.ams) {
+              isDone = true;
+              clearTimeout(timer);
+              client.end(true);
+              resolve(parseBambuAmsState(data.print));
+            }
+          }
+        } catch {}
+      });
+
+      client.on('error', () => {
+        if (isDone) return;
+        isDone = true;
+        clearTimeout(timer);
+        try { client.end(true); } catch {}
+        if (cached?.print?.ams) {
+          resolve(parseBambuAmsState(cached.print));
+        } else {
+          resolve({ available: false, slots: [], readAt: new Date().toISOString() });
+        }
+      });
+    });
   }
 
   throw new Error(`Ação "${action}" não suportada`);