project-foundry 1.0.0 → 1.0.2

package/bin/foundry.js

@@ -126,6 +126,9 @@ program
     } catch (err) {
       s.stop(pc.red('Erro durante o pareamento'));
       p.log.error(err.message || 'Falha ao registrar nó');
+      if (err.cause) {
+        p.log.error(pc.dim(`Detalhes técnicos: ${err.cause?.message || err.cause?.code || err.cause}`));
+      }
       process.exit(1);
     }
   });

package/package.json

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

package/src/api-client.js

@@ -1,5 +1,56 @@
+import https from 'node:https';
+import http from 'node:http';
 import os from 'node:os';
 
+async function postJson(targetUrl, payload) {
+  const parsed = new URL(targetUrl);
+  const isHttps = parsed.protocol === 'https:';
+  const transport = isHttps ? https : http;
+  const postData = JSON.stringify(payload);
+
+  return new Promise((resolve, reject) => {
+    const req = transport.request(parsed, {
+      method: 'POST',
+      family: 4,
+      rejectUnauthorized: false,
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData),
+        'User-Agent': 'Project-Foundry-CLI/1.0',
+      },
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const parsedBody = body ? JSON.parse(body) : {};
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsedBody.data);
+          } else {
+            const err = new Error(parsedBody?.error?.message || `HTTP ${res.statusCode}: ${body.slice(0, 100)}`);
+            err.code = parsedBody?.error?.code;
+            reject(err);
+          }
+        } catch {
+          reject(new Error(`Resposta inválida do servidor: HTTP ${res.statusCode}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(new Error(`Falha de conexão com ${parsed.host} (${err.code || err.message})`));
+    });
+
+    req.setTimeout(15000, () => {
+      req.destroy();
+      reject(new Error(`Tempo limite esgotado ao contatar ${parsed.host}`));
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
 export async function registerNodeWithCloud({ serverUrl, token, name }) {
   const url = `${serverUrl.replace(/\/$/, '')}/api/v1/nodes/register`;
 
@@ -11,20 +62,7 @@ export async function registerNodeWithCloud({ serverUrl, token, name }) {
     name: name || `Servidor ${os.hostname()}`,
   };
 
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(payload),
-  });
-
-  const body = await response.json().catch(() => ({}));
-
-  if (!response.ok) {
-    const errorMsg = body?.error?.message || 'Falha ao registrar nó na nuvem';
-    throw new Error(errorMsg);
-  }
-
-  return body.data;
+  return await postJson(url, payload);
 }
 
 export async function fetchServerTelemetry(port = 3010) {

package/src/daemon.js

@@ -1,4 +1,5 @@
 import http from 'node:http';
+import https from 'node:https';
 import fs from 'node:fs';
 import path from 'node:path';
 import { readConfig } from './config.js';
@@ -75,10 +76,14 @@ export function startDaemon() {
 
       fileStream.on('finish', async () => {
         try {
-          // Encaminha requisição completa com cabeçalhos para a nuvem
           const cloudUrl = `${config.serverUrl.replace(/\/$/, '')}${url.pathname}`;
-          const cloudReq = http.request(cloudUrl, {
+          const isHttps = cloudUrl.startsWith('https:');
+          const transport = isHttps ? https : http;
+
+          const cloudReq = transport.request(cloudUrl, {
             method: 'POST',
+            family: 4,
+            rejectUnauthorized: false,
             headers: {
               ...req.headers,
               host: new URL(config.serverUrl).host,
@@ -111,14 +116,16 @@ export function startDaemon() {
       return;
     }
 
-    // Proxy reverso padrão para outras rotas em direção à Nuvem
+    // Proxy reverso para todas as outras requisições
     try {
       const targetUrl = new URL(req.url, config.serverUrl);
       const isHttps = targetUrl.protocol === 'https:';
-      const transport = isHttps ? await import('node:https') : await import('node:http');
+      const transport = isHttps ? https : http;
 
       const proxyReq = transport.request(targetUrl, {
         method: req.method,
+        family: 4,
+        rejectUnauthorized: false,
         headers: {
           ...req.headers,
           host: targetUrl.host,

package/src/local-printer-executor.js

@@ -0,0 +1,120 @@
+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');
+  }
+
+  const type = connectionConfig.type;
+  const baseUrl = (connectionConfig.url || `http://${connectionConfig.host}:${connectionConfig.port || 80}`).replace(/\/$/, '');
+  const apiKey = connectionConfig.apiKey;
+  const headers = apiKey ? { 'X-Api-Key': apiKey } : {};
+
+  // 1. Verificação de Conexão
+  if (action === 'connect') {
+    if (type === 'klipper') {
+      const infoRes = await fetch(`${baseUrl}/server/info`, { headers, signal: AbortSignal.timeout(8000) });
+      if (!infoRes.ok) {
+        throw new Error(`Moonraker retornou HTTP ${infoRes.status}: ${infoRes.statusText}`);
+      }
+      const info = await infoRes.json();
+      const klippyState = info?.result?.klippy_state || 'ready';
+
+      let status = klippyState === 'ready' ? 'IDLE' : 'ERROR';
+      let message = `Klipper: ${klippyState}`;
+      let temperatures = {};
+
+      try {
+        const telRes = await fetch(
+          `${baseUrl}/printer/objects/query?print_stats&extruder&heater_bed`,
+          { headers, signal: AbortSignal.timeout(5000) }
+        );
+        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();
+          if (st === 'printing') status = 'PRINTING';
+          else if (st === 'paused') status = 'PAUSED';
+
+          temperatures = {
+            hotend: ext.temperature,
+            hotendTarget: ext.target,
+            bed: bed.temperature,
+            bedTarget: bed.target,
+          };
+          if (stats.message) message = stats.message;
+        }
+      } catch {}
+
+      return {
+        online: true,
+        status,
+        message,
+        temperatures,
+      };
+    }
+
+    if (type === 'octoprint') {
+      const verRes = await fetch(`${baseUrl}/api/version`, { headers, signal: AbortSignal.timeout(8000) });
+      if (!verRes.ok) {
+        throw new Error(`OctoPrint retornou HTTP ${verRes.status}: ${verRes.statusText}`);
+      }
+      return {
+        online: true,
+        status: 'IDLE',
+        message: 'OctoPrint conectado com sucesso',
+      };
+    }
+
+    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) });
+    if (!camRes.ok) {
+      throw new Error(`Câmera retornou HTTP ${camRes.status}: ${camRes.statusText}`);
+    }
+    const buf = await camRes.arrayBuffer();
+    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') {
+      const cmdMap = {
+        pause: '/printer/print/pause',
+        resume: '/printer/print/resume',
+        cancel: '/printer/print/cancel',
+        emergency_stop: '/printer/emergency_stop',
+        restart: '/printer/restart',
+        firmware_restart: '/printer/firmware_restart',
+      };
+      const endpoint = cmdMap[cmd];
+      if (!endpoint) throw new Error(`Comando de controle "${cmd}" não suportado em Klipper`);
+      const res = await fetch(`${baseUrl}${endpoint}`, { method: 'POST', headers, signal: AbortSignal.timeout(8000) });
+      return { success: res.ok };
+    }
+  }
+
+  // 4. Comandos de Trabalho (Job Pause / Resume / Cancel)
+  if (action.startsWith('job/')) {
+    const jobCmd = action.replace('job/', '');
+    if (type === 'klipper') {
+      const cmdMap = {
+        pause: '/printer/print/pause',
+        resume: '/printer/print/resume',
+        cancel: '/printer/print/cancel',
+      };
+      const endpoint = cmdMap[jobCmd];
+      if (endpoint) {
+        const res = await fetch(`${baseUrl}${endpoint}`, { method: 'POST', headers, signal: AbortSignal.timeout(8000) });
+        return { success: res.ok };
+      }
+    }
+  }
+
+  throw new Error(`Ação "${action}" não suportada`);
+}

package/src/tunnel-client.js

@@ -1,5 +1,6 @@
 import WebSocket from 'ws';
 import { readConfig } from './config.js';
+import { executeLocalPrinterAction } from './local-printer-executor.js';
 
 export class EdgeTunnelClient {
   constructor() {
@@ -45,6 +46,7 @@ export class EdgeTunnelClient {
     try {
       this.ws = new WebSocket(url, {
         rejectUnauthorized: false,
+        family: 4,
       });
 
       this.ws.on('open', () => {
@@ -89,52 +91,19 @@ export class EdgeTunnelClient {
   }
 
   async handleCloudCommand(msg) {
-    const config = readConfig();
-    const localPort = config?.localPort || 3010;
-    const localBase = `http://127.0.0.1:${localPort}/api/v1`;
-    const headers = {
-      'Content-Type': 'application/json',
-      'X-Api-Key': config.apiKey,
-    };
-
     try {
       let resultData = null;
 
-      if (msg.action === 'camera/snapshot') {
-        const snapRes = await fetch(`${localBase}/printers/${msg.printerId}/camera/snapshot`, {
-          headers: { 'X-Api-Key': config.apiKey },
-        });
-        if (!snapRes.ok) throw new Error(`Snapshot falhou: HTTP ${snapRes.status}`);
-        const arrayBuf = await snapRes.arrayBuffer();
-        resultData = { base64: Buffer.from(arrayBuf).toString('base64') };
-      } else if (msg.action === 'control') {
-        const cRes = await fetch(`${localBase}/printers/${msg.printerId}/control`, {
-          method: 'POST',
-          headers,
-          body: JSON.stringify(msg.payload || {}),
-        });
-        const cJson = await cRes.json();
-        if (!cRes.ok) throw new Error(cJson?.error?.message || 'Falha no comando de controle');
-        resultData = cJson.data;
-      } else if (msg.action === 'connect') {
-        const connRes = await fetch(`${localBase}/printers/${msg.printerId}/connect`, {
-          method: 'POST',
-          headers,
-          body: JSON.stringify({}),
-        });
-        const connJson = await connRes.json();
-        if (!connRes.ok) throw new Error(connJson?.error?.message || 'Falha ao conectar à impressora local');
-        resultData = connJson.data;
-      } else if (msg.action.startsWith('job/')) {
-        const jobAction = msg.action.replace('job/', '');
-        const jRes = await fetch(`${localBase}/jobs/${msg.payload?.jobId}/${jobAction}`, {
-          method: 'POST',
-          headers,
-          body: JSON.stringify({}),
+      if (msg.payload?.connectionConfig) {
+        // Executa diretamente na rede local (LAN) da farm
+        resultData = await executeLocalPrinterAction({
+          action: msg.action,
+          printerId: msg.printerId,
+          connectionConfig: msg.payload.connectionConfig,
+          payload: msg.payload,
         });
-        const jJson = await jRes.json();
-        if (!jRes.ok) throw new Error(jJson?.error?.message || `Falha no comando do trabalho: ${jobAction}`);
-        resultData = jJson.data;
+      } else {
+        throw new Error('Configuração de conexão da impressora não foi fornecida pelo servidor central');
       }
 
       if (this.ws && this.ws.readyState === WebSocket.OPEN) {