project-foundry 1.0.1 → 1.0.3

package/package.json

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

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/service-manager.js

@@ -2,6 +2,7 @@ import { execSync, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { getConfigDir } from './config.js';
 
 export async function isServerHealthy(port = 3010) {
   try {
@@ -15,13 +16,71 @@ export async function isServerHealthy(port = 3010) {
   }
 }
 
+export function stopRunningDaemon() {
+  const isWin = process.platform === 'win32';
+  if (isWin) {
+    try {
+      execSync('schtasks /end /tn "ProjectFoundry"', { stdio: 'ignore' });
+    } catch {}
+  } else {
+    try {
+      execSync('systemctl stop foundry.service', { stdio: 'ignore' });
+    } catch {}
+    try {
+      execSync('systemctl --user stop foundry.service', { stdio: 'ignore' });
+    } catch {}
+    try {
+      execSync("pkill -f 'foundry.*daemon' || true", { stdio: 'ignore' });
+    } catch {}
+  }
+}
+
+export function restartAutostartService() {
+  const isWin = process.platform === 'win32';
+  if (isWin) {
+    try {
+      execSync('schtasks /run /tn "ProjectFoundry"', { stdio: 'ignore' });
+    } catch {}
+  } else {
+    try {
+      execSync('systemctl restart foundry.service', { stdio: 'ignore' });
+    } catch {
+      try {
+        execSync('systemctl --user restart foundry.service', { stdio: 'ignore' });
+      } catch {}
+    }
+  }
+}
+
+export function ensurePermanentAppPath(entryPath) {
+  const rootDir = path.resolve(path.dirname(entryPath), '..');
+
+  // Se estiver rodando de cache temporário do npx ou temp
+  if (entryPath.includes('_npx') || entryPath.includes('npm-cache') || entryPath.includes('Temp') || entryPath.includes('tmp')) {
+    const permanentAppDir = path.join(getConfigDir(), 'app');
+    if (!fs.existsSync(permanentAppDir)) {
+      fs.mkdirSync(permanentAppDir, { recursive: true });
+    }
+    try {
+      // Copia arquivos do pacote para local permanente
+      fs.cpSync(rootDir, permanentAppDir, { recursive: true });
+      const permanentEntry = path.join(permanentAppDir, 'bin', 'foundry.js');
+      if (fs.existsSync(permanentEntry)) {
+        return permanentEntry;
+      }
+    } catch {}
+  }
+  return entryPath;
+}
+
 export function installAutostartService(serverEntryPath) {
   const isWin = process.platform === 'win32';
+  const permanentPath = ensurePermanentAppPath(serverEntryPath);
 
   if (isWin) {
     try {
       // Cria tarefa no Agendador do Windows com início automático em modo daemon
-      const cmd = `schtasks /create /tn "ProjectFoundry" /tr "node \\"${serverEntryPath}\\" daemon" /sc onstart /f`;
+      const cmd = `schtasks /create /tn "ProjectFoundry" /tr "node \\"${permanentPath}\\" daemon" /sc onstart /f`;
       execSync(cmd, { stdio: 'pipe' });
       return { success: true, type: 'windows-task', name: 'ProjectFoundry' };
     } catch (err) {
@@ -32,13 +91,14 @@ export function installAutostartService(serverEntryPath) {
   // Linux (systemd)
   try {
     const isRoot = typeof process.getuid === 'function' && process.getuid() === 0;
+    const nodeBin = process.execPath || '/usr/bin/node';
     const serviceContent = `[Unit]
-Description=Project Foundry Local Server
+Description=Project Foundry Local Farm Server
 After=network.target
 
 [Service]
 Type=simple
-ExecStart=/usr/bin/node ${serverEntryPath} daemon
+ExecStart=${nodeBin} ${permanentPath} daemon
 Restart=always
 RestartSec=5
 Environment=NODE_ENV=production
@@ -49,13 +109,13 @@ WantedBy=default.target
 
     if (isRoot) {
       fs.writeFileSync('/etc/systemd/system/foundry.service', serviceContent, 'utf8');
-      execSync('systemctl daemon-reload && systemctl enable foundry.service', { stdio: 'pipe' });
+      execSync('systemctl daemon-reload && systemctl enable foundry.service && systemctl restart foundry.service', { stdio: 'pipe' });
       return { success: true, type: 'systemd-system', name: 'foundry.service' };
     } else {
       const userSystemdDir = path.join(os.homedir(), '.config', 'systemd', 'user');
       fs.mkdirSync(userSystemdDir, { recursive: true });
       fs.writeFileSync(path.join(userSystemdDir, 'foundry.service'), serviceContent, 'utf8');
-      execSync('systemctl --user daemon-reload && systemctl --user enable foundry.service', { stdio: 'pipe' });
+      execSync('systemctl --user daemon-reload && systemctl --user enable foundry.service && systemctl --user restart foundry.service', { stdio: 'pipe' });
       return { success: true, type: 'systemd-user', name: 'foundry.service' };
     }
   } catch (err) {
@@ -64,8 +124,8 @@ WantedBy=default.target
 }
 
 export function startDaemonBackground(serverEntryPath) {
-  // Inicia desacoplado do terminal para não travar
-  const child = spawn(process.execPath, [serverEntryPath, 'daemon'], {
+  const permanentPath = ensurePermanentAppPath(serverEntryPath);
+  const child = spawn(process.execPath, [permanentPath, 'daemon'], {
     detached: true,
     stdio: 'ignore',
   });

package/src/tui.js

@@ -1,12 +1,27 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import open from 'open';
 import { readConfig, updateStoragePath } from './config.js';
-import { isServerHealthy } from './service-manager.js';
+import { isServerHealthy, stopRunningDaemon, restartAutostartService } from './service-manager.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getPackageVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    return `v${pkg.version}`;
+  } catch {
+    return 'v1.0.3';
+  }
+}
 
 export async function runInteractiveTui() {
   const config = readConfig();
-  const version = 'v1.0.0';
+  const version = getPackageVersion();
   const localPort = config?.localPort || 3010;
   const localUrl = `http://localhost:${localPort}`;
 
@@ -33,7 +48,7 @@ export async function runInteractiveTui() {
   } else {
     p.note(
       `${pc.yellow('○')} O servidor local não respondeu em ${localUrl}.\n` +
-      `Ele pode estar iniciando ou parado.`,
+      `O serviço pode estar iniciando em segundo plano ou parado.`,
       'Atenção'
     );
   }
@@ -43,16 +58,16 @@ export async function runInteractiveTui() {
       message: 'Escolha uma opção:',
       options: [
         { value: 'web', label: 'Web UI (Open in Browser)', hint: 'Abre o painel no navegador' },
-        { value: 'status', label: 'Terminal UI (Status & Health)', hint: 'Verifica conexões locais' },
+        { value: 'status', label: 'Terminal UI (Status & Health)', hint: 'Verifica saúde e conexões locais' },
         { value: 'storage', label: 'Storage (HD Externo)', hint: 'Visualizar ou alterar pasta de arquivos' },
-        { value: 'update', label: `Update (current: ${version})`, hint: 'Verifica atualizações' },
-        { value: 'hide', label: 'Hide to Tray (Background)', hint: 'Mantém servidor rodando em segundo plano' },
-        { value: 'exit', label: 'Exit', hint: 'Fechar console' },
+        { value: 'update', label: `Update (current: ${version})`, hint: 'Verifica e atualiza para versão mais recente' },
+        { value: 'hide', label: 'Hide to Tray (Background)', hint: 'Fecha o console e mantém o servidor rodando' },
+        { value: 'stop', label: 'Stop Server', hint: 'Desliga o servidor local da farm' },
       ],
     });
 
     if (p.isCancel(choice) || choice === 'hide') {
-      p.outro(pc.green('Servidor mantido rodando em segundo plano. Digite "foundry" para reabrir este menu.'));
+      p.outro(pc.green('Painel fechado. O servidor da farm continua rodando em segundo plano.'));
       process.exit(0);
     }
 
@@ -100,19 +115,56 @@ export async function runInteractiveTui() {
     }
 
     if (choice === 'update') {
-      p.log.info('Você já está na versão mais recente instalada.');
+      const s = p.spinner();
+      s.start('Verificando versão mais recente no npm...');
+      try {
+        const res = await fetch('https://registry.npmjs.org/project-foundry/latest', {
+          signal: AbortSignal.timeout(6000),
+        });
+        const data = await res.json();
+        const latestVersion = `v${data.version}`;
+        s.stop();
+
+        if (latestVersion !== version) {
+          p.log.warn(`Nova versão disponível: ${pc.green(latestVersion)} (você está na ${version})`);
+          const doUpdate = await p.confirm({
+            message: `Deseja atualizar para a versão ${latestVersion}?`,
+            initialValue: true,
+          });
+
+          if (doUpdate && !p.isCancel(doUpdate)) {
+            s.start('Atualizando pacote e reiniciando serviço...');
+            try {
+              execSync('npm install -g project-foundry@latest', { stdio: 'pipe' });
+              restartAutostartService();
+              s.stop(pc.green(`Atualizado para ${latestVersion} com sucesso!`));
+              p.outro(pc.cyan('Reinicie o menu com "foundry" ou "npx project-foundry" para aplicar.'));
+              process.exit(0);
+            } catch (err) {
+              s.stop(pc.yellow(`Atualização global não permitida sem sudo. Execute no terminal: npm install -g project-foundry@latest`));
+            }
+          }
+        } else {
+          p.log.success(`Você já está na versão mais recente (${version}).`);
+        }
+      } catch (err) {
+        s.stop(pc.red(`Erro ao verificar: ${err.message}`));
+      }
     }
 
-    if (choice === 'exit') {
+    if (choice === 'stop') {
       const shouldStop = await p.confirm({
-        message: 'Deseja apenas fechar o console ou parar o serviço?',
-        active: 'Apenas fechar console (manter servidor ligado)',
-        inactive: 'Fechar console',
-        initialValue: true,
+        message: 'Atenção: deseja realmente parar o servidor local da farm?',
+        active: 'Sim, parar servidor completamente',
+        inactive: 'Não, manter ligado',
+        initialValue: false,
       });
 
-      p.outro(pc.cyan('Até logo! O servidor continua em segundo plano.'));
-      process.exit(0);
+      if (shouldStop && !p.isCancel(shouldStop)) {
+        stopRunningDaemon();
+        p.outro(pc.yellow('Servidor local encerrado. Para religar, execute "foundry" no terminal.'));
+        process.exit(0);
+      }
     }
   }
 }

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() {
@@ -90,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) {