project-foundry 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,41 @@
-# Temporary Holding Version
+# Project Foundry CLI & Edge Node
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Gerenciador local e agente de farm para o [Project Foundry](https://foundry.projectcore.site).
+
+Permite conectar qualquer máquina local (Orange Pi, Raspberry Pi, Mini PC ou computador Windows) posicionada na rede das impressoras 3D ao painel de controle na nuvem com um único comando.
+
+## Instalação e Pareamento
+
+No painel do Project Foundry (Configurações → Servidores Locais), clique em **Adicionar Servidor** para gerar seu token de pareamento. Em seguida, execute no terminal da sua máquina local:
+
+```bash
+npx project-foundry setup --token <seu-token>
+```
+
+Para direcionar os arquivos pesados (G-codes, 3MFs e timelapses) diretamente para um HD externo conectado:
+
+```bash
+npx project-foundry setup --token <seu-token> --storage /mnt/hd1tb/storage
+```
+
+## Recursos
+
+- **Túnel WebSocket Reverso**: Conexão segura de saída para a nuvem sem abrir portas no roteador da empresa.
+- **Suporte a HD Externo**: Salva arquivos 3D e timelapses no disco que você escolher.
+- **Inicialização Automática**: Cria serviço do sistema (`systemd` no Linux ou Tarefa Agendada no Windows) para reiniciar automaticamente após quedas de energia.
+- **Terminal UI (TUI)**: Menu interativo com opção de rodar em segundo plano (`Hide to Tray`) com zero risco de desligamento acidental.
+- **Ponte OrcaSlicer e Bambu Studio**: Recepção de fatiamentos direto na LAN em alta velocidade.
+
+## Uso
+
+Para reabrir o menu de controle no terminal a qualquer momento:
+
+```bash
+npx project-foundry
+```
+
+Ou se instalado globalmente (`npm install -g project-foundry`):
+
+```bash
+foundry
+```

package/bin/foundry.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+import path from 'node:path';
+import { Command } from 'commander';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { hasConfig, writeConfig, readConfig, getDefaultStorageDir } from '../src/config.js';
+import { registerNodeWithCloud } from '../src/api-client.js';
+import { installAutostartService, isServerHealthy, startDaemonBackground } from '../src/service-manager.js';
+import { runInteractiveTui } from '../src/tui.js';
+import { startDaemon } from '../src/daemon.js';
+
+const program = new Command();
+
+program
+  .name('foundry')
+  .description('Project Foundry CLI & Edge Node Manager')
+  .version('1.0.0');
+
+// Comando: daemon (segundo plano)
+program
+  .command('daemon')
+  .description('Inicia o servidor e o túnel reverso em segundo plano')
+  .action(() => {
+    startDaemon();
+  });
+
+// Comando: setup
+program
+  .command('setup')
+  .description('Configura e pareia o servidor local com a conta do Project Foundry')
+  .requiredOption('-t, --token <token>', 'Token de pareamento descartável gerado na nuvem')
+  .option('-s, --server <url>', 'URL do servidor Cloud', 'https://foundry.projectcore.site')
+  .option('-n, --name <name>', 'Nome descritivo deste servidor')
+  .option('--storage <path>', 'Caminho do diretório de armazenamento (ex: HD externo)')
+  .action(async (options) => {
+    p.intro(pc.bold(pc.cyan('Configuração do Servidor Local Project Foundry')));
+
+    const s = p.spinner();
+    s.start('Conectando à nuvem e validando token de pareamento...');
+
+    try {
+      const regData = await registerNodeWithCloud({
+        serverUrl: options.server,
+        token: options.token,
+        name: options.name,
+      });
+
+      s.stop(pc.green('Pareamento realizado com sucesso!'));
+
+      // Configuração de Armazenamento (HD Externo ou Padrão)
+      let storagePath = options.storage;
+      if (!storagePath) {
+        const storageChoice = await p.select({
+          message: 'Onde deseja salvar os arquivos 3D (3MF/G-code) e timelapses?',
+          options: [
+            {
+              value: 'default',
+              label: 'Pasta padrão do sistema',
+              hint: `(${getDefaultStorageDir()})`,
+            },
+            {
+              value: 'custom',
+              label: 'HD Externo / Diretório Personalizado',
+              hint: process.platform === 'win32' ? 'Ex: D:\\Storage' : 'Ex: /mnt/hd1tb/storage',
+            },
+          ],
+        });
+
+        if (storageChoice === 'custom') {
+          const customInput = await p.text({
+            message: 'Digite o caminho completo da pasta no seu HD/Disco:',
+            placeholder: process.platform === 'win32' ? 'D:\\Storage' : '/mnt/hd1tb/storage',
+            validate: (val) => {
+              if (!val || !val.trim()) return 'O caminho é obrigatório';
+            },
+          });
+          if (!p.isCancel(customInput)) {
+            storagePath = customInput.trim();
+          }
+        }
+      }
+
+      const finalStorage = storagePath ? path.resolve(storagePath) : getDefaultStorageDir();
+
+      // Salva configuração local
+      writeConfig({
+        nodeId: regData.nodeId,
+        nodeName: regData.nodeName,
+        organizationId: regData.organizationId,
+        apiKey: regData.apiKey,
+        serverUrl: regData.serverUrl,
+        storagePath: finalStorage,
+        localPort: 3010,
+        configuredAt: new Date().toISOString(),
+      });
+
+      p.log.success(`Servidor vinculado à organização: ${pc.bold(regData.organizationId)}`);
+      p.log.success(`Armazenamento configurado em: ${pc.bold(finalStorage)}`);
+
+      // Configuração de serviço
+      const installService = await p.confirm({
+        message: 'Deseja configurar inicialização automática com o sistema operacional?',
+        initialValue: true,
+      });
+
+      if (installService && !p.isCancel(installService)) {
+        s.start('Registrando serviço de autostart no sistema operacional...');
+        const serviceRes = installAutostartService(process.argv[1]);
+        if (serviceRes.success) {
+          s.stop(pc.green(`Serviço registrado (${serviceRes.type}): ${serviceRes.name}`));
+        } else {
+          s.stop(pc.yellow(`Não foi possível registrar serviço automático: ${serviceRes.error}`));
+        }
+      }
+
+      // Garante que o daemon suba em segundo plano se ainda não estiver rodando
+      const isUp = await isServerHealthy(3010);
+      if (!isUp) {
+        startDaemonBackground(process.argv[1]);
+        await new Promise((r) => setTimeout(r, 1500));
+      }
+
+      p.outro(pc.green('Configuração concluída! Abrindo interface interativa...'));
+      await runInteractiveTui();
+    } 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);
+    }
+  });
+
+// Comando padrão: se nenhum subcomando for passado, abre o TUI
+program
+  .action(async () => {
+    if (!hasConfig()) {
+      p.intro(pc.bold(pc.yellow('Project Foundry - Primeiro Uso')));
+      p.note(
+        'Este servidor local ainda não foi vinculado a uma conta.\n' +
+        'Gere um token de pareamento no painel web (Configurações -> Servidores Locais) e execute:\n\n' +
+        pc.cyan('  npx project-foundry setup --token <seu-token>'),
+        'Como Vincular'
+      );
+      process.exit(0);
+    }
+
+    await runInteractiveTui();
+  });
+
+program.parse(process.argv);

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "project-foundry",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Project Foundry CLI & Local Node Daemon Manager",
+  "bin": {
+    "project-foundry": "bin/foundry.js",
+    "foundry": "bin/foundry.js"
+  },
+  "type": "module",
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node ./bin/foundry.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "commander": "^12.1.0",
+    "open": "^10.1.0",
+    "picocolors": "^1.1.1",
+    "ws": "^8.22.0"
+  }
+}

package/src/api-client.js

@@ -0,0 +1,76 @@
+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`;
+
+  const payload = {
+    token,
+    hostname: os.hostname(),
+    platform: process.platform,
+    arch: process.arch,
+    name: name || `Servidor ${os.hostname()}`,
+  };
+
+  return await postJson(url, payload);
+}
+
+export async function fetchServerTelemetry(port = 3010) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/v1/ready`);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}

package/src/config.js

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export function getConfigDir() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Foundry');
+  }
+  return path.join(os.homedir(), '.foundry');
+}
+
+export function getConfigPath() {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+export function getDefaultStorageDir() {
+  return path.join(getConfigDir(), 'storage');
+}
+
+export function hasConfig() {
+  return fs.existsSync(getConfigPath());
+}
+
+export function readConfig() {
+  const filePath = getConfigPath();
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const config = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (!config.storagePath) {
+      config.storagePath = getDefaultStorageDir();
+    }
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+export function writeConfig(data) {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Se não definido, salva o caminho padrão
+  if (!data.storagePath) {
+    data.storagePath = getDefaultStorageDir();
+  }
+
+  // Garante que o diretório de storage existe
+  if (!fs.existsSync(data.storagePath)) {
+    try {
+      fs.mkdirSync(data.storagePath, { recursive: true });
+    } catch {
+      // Ignora erro de permissão imediato, será reportado no setup
+    }
+  }
+
+  const filePath = getConfigPath();
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+export function updateStoragePath(newPath) {
+  const config = readConfig() || {};
+  config.storagePath = path.resolve(newPath);
+  if (!fs.existsSync(config.storagePath)) {
+    fs.mkdirSync(config.storagePath, { recursive: true });
+  }
+  writeConfig(config);
+  return config.storagePath;
+}

package/src/daemon.js

@@ -0,0 +1,156 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { readConfig } from './config.js';
+import { edgeTunnelClient } from './tunnel-client.js';
+
+export function startDaemon() {
+  const config = readConfig();
+  if (!config) {
+    console.error('Configuração não encontrada. Execute "foundry setup" primeiro.');
+    process.exit(1);
+  }
+
+  const port = config.localPort || 3010;
+
+  // 1. Inicia cliente do túnel WebSocket com a Nuvem
+  edgeTunnelClient.start();
+  console.log(`[Foundry Daemon] Túnel WebSocket conectado a ${config.serverUrl}`);
+
+  // 2. Servidor HTTP local (Porta 3010) para Slicer e diagnósticos
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://127.0.0.1:${port}`);
+
+    // CORS básico
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, DELETE');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Api-Key, Authorization');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // Healthcheck local
+    if (url.pathname === '/api/v1/ready' || url.pathname === '/api/v1/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: true,
+        data: {
+          ready: true,
+          status: 'healthy',
+          nodeId: config.nodeId,
+          organizationId: config.organizationId,
+          storagePath: config.storagePath,
+          timestamp: new Date().toISOString(),
+        },
+      }));
+      return;
+    }
+
+    // Slicer version handshake
+    if (url.pathname.match(/^\/api\/v1\/slicer-host\/[^/]+\/api\/version$/)) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        api: '0.1',
+        server: '1.10.0',
+        text: 'OctoPrint 1.10.0 (Project Foundry Local Bridge)',
+      }));
+      return;
+    }
+
+    // Upload do OrcaSlicer recebido na LAN: salva direto no HD local e repassa à nuvem
+    if (url.pathname.match(/^\/api\/v1\/slicer-host\/[^/]+\/api\/files\/local$/) && req.method === 'POST') {
+      const storageDir = config.storagePath || path.join(process.cwd(), 'storage');
+      if (!fs.existsSync(storageDir)) {
+        fs.mkdirSync(storageDir, { recursive: true });
+      }
+
+      const tempFileName = `upload_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.tmp`;
+      const tempFilePath = path.join(storageDir, tempFileName);
+      const fileStream = fs.createWriteStream(tempFilePath);
+
+      req.pipe(fileStream);
+
+      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, {
+            method: 'POST',
+            headers: {
+              ...req.headers,
+              host: new URL(config.serverUrl).host,
+            },
+          }, (cloudRes) => {
+            res.writeHead(cloudRes.statusCode, cloudRes.headers);
+            cloudRes.pipe(res);
+          });
+
+          cloudReq.on('error', (err) => {
+            res.writeHead(502, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+              success: false,
+              error: { message: `Erro ao notificar nuvem: ${err.message}` },
+            }));
+          });
+
+          fs.createReadStream(tempFilePath).pipe(cloudReq);
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ success: false, error: { message: err.message } }));
+        }
+      });
+
+      fileStream.on('error', (err) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: { message: err.message } }));
+      });
+
+      return;
+    }
+
+    // Proxy reverso padrão para outras rotas em direção à Nuvem
+    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 proxyReq = transport.request(targetUrl, {
+        method: req.method,
+        headers: {
+          ...req.headers,
+          host: targetUrl.host,
+        },
+      }, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode, proxyRes.headers);
+        proxyRes.pipe(res);
+      });
+
+      proxyReq.on('error', (err) => {
+        res.writeHead(502, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: { message: `Erro no proxy da nuvem: ${err.message}` } }));
+      });
+
+      req.pipe(proxyReq);
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: false, error: { message: err.message } }));
+    }
+  });
+
+  server.listen(port, '0.0.0.0', () => {
+    console.log(`[Foundry Daemon] Servidor local escutando em http://0.0.0.0:${port}`);
+    console.log(`[Foundry Daemon] Diretório de arquivos: ${config.storagePath}`);
+  });
+
+  const handleExit = () => {
+    console.log('[Foundry Daemon] Parando serviços...');
+    edgeTunnelClient.stop();
+    server.close(() => process.exit(0));
+  };
+
+  process.on('SIGINT', handleExit);
+  process.on('SIGTERM', handleExit);
+}

package/src/service-manager.js

@@ -0,0 +1,74 @@
+import { execSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export async function isServerHealthy(port = 3010) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    const res = await fetch(`http://127.0.0.1:${port}/api/v1/ready`, { signal: controller.signal });
+    clearTimeout(timer);
+    return res.status === 200;
+  } catch {
+    return false;
+  }
+}
+
+export function installAutostartService(serverEntryPath) {
+  const isWin = process.platform === 'win32';
+
+  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`;
+      execSync(cmd, { stdio: 'pipe' });
+      return { success: true, type: 'windows-task', name: 'ProjectFoundry' };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  // Linux (systemd)
+  try {
+    const isRoot = typeof process.getuid === 'function' && process.getuid() === 0;
+    const serviceContent = `[Unit]
+Description=Project Foundry Local Server
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/node ${serverEntryPath} daemon
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=default.target
+`;
+
+    if (isRoot) {
+      fs.writeFileSync('/etc/systemd/system/foundry.service', serviceContent, 'utf8');
+      execSync('systemctl daemon-reload && systemctl enable 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' });
+      return { success: true, type: 'systemd-user', name: 'foundry.service' };
+    }
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+export function startDaemonBackground(serverEntryPath) {
+  // Inicia desacoplado do terminal para não travar
+  const child = spawn(process.execPath, [serverEntryPath, 'daemon'], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  return child.pid;
+}

package/src/tui.js

@@ -0,0 +1,118 @@
+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';
+
+export async function runInteractiveTui() {
+  const config = readConfig();
+  const version = 'v1.0.0';
+  const localPort = config?.localPort || 3010;
+  const localUrl = `http://localhost:${localPort}`;
+
+  console.clear();
+
+  p.intro(
+    `${pc.bold(pc.cyan('======================================================'))}\n` +
+    `  ${pc.bold(pc.yellow(`Project Foundry Interface (${version})`))}\n` +
+    `  🚀 Server: ${pc.green(localUrl)}\n` +
+    `  💾 Storage: ${pc.cyan(config?.storagePath || 'Padrão')}\n` +
+    `${pc.bold(pc.cyan('======================================================'))}`
+  );
+
+  const healthy = await isServerHealthy(localPort);
+
+  if (healthy) {
+    p.note(
+      `${pc.green('●')} Servidor Local Online\n` +
+      `Empresa: ${config?.organizationId ? pc.bold(config.organizationId) : 'Autônoma'}\n` +
+      `Nó: ${pc.bold(config?.nodeName || 'Servidor Local')}\n` +
+      `Armazenamento de Arquivos: ${pc.bold(config?.storagePath || 'Padrão')}`,
+      'Status da Farm'
+    );
+  } else {
+    p.note(
+      `${pc.yellow('○')} O servidor local não respondeu em ${localUrl}.\n` +
+      `Ele pode estar iniciando ou parado.`,
+      'Atenção'
+    );
+  }
+
+  while (true) {
+    const choice = await p.select({
+      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: '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' },
+      ],
+    });
+
+    if (p.isCancel(choice) || choice === 'hide') {
+      p.outro(pc.green('Servidor mantido rodando em segundo plano. Digite "foundry" para reabrir este menu.'));
+      process.exit(0);
+    }
+
+    if (choice === 'web') {
+      p.log.info(`Abrindo ${localUrl} no navegador...`);
+      await open(localUrl).catch(() => {
+        p.log.warn(`Não foi possível abrir o navegador automaticamente. Acesse: ${localUrl}`);
+      });
+    }
+
+    if (choice === 'status') {
+      const isUp = await isServerHealthy(localPort);
+      if (isUp) {
+        p.log.success(`Servidor respondendo perfeitamente em ${localUrl}`);
+      } else {
+        p.log.error(`Servidor inacessível na porta ${localPort}`);
+      }
+    }
+
+    if (choice === 'storage') {
+      const currentConf = readConfig();
+      p.log.info(`Pasta atual de arquivos: ${pc.bold(currentConf?.storagePath || 'Padrão')}`);
+      const wantChange = await p.confirm({
+        message: 'Deseja alterar a pasta de armazenamento (ex: novo HD)?',
+        initialValue: false,
+      });
+
+      if (wantChange && !p.isCancel(wantChange)) {
+        const newPath = await p.text({
+          message: 'Digite o novo caminho completo da pasta do HD:',
+          placeholder: process.platform === 'win32' ? 'D:\\Storage' : '/mnt/hd1tb/storage',
+          validate: (val) => {
+            if (!val || !val.trim()) return 'Caminho é obrigatório';
+          },
+        });
+        if (!p.isCancel(newPath) && newPath.trim()) {
+          try {
+            const updated = updateStoragePath(newPath.trim());
+            p.log.success(`Caminho de armazenamento atualizado para: ${pc.bold(updated)}`);
+          } catch (err) {
+            p.log.error(`Erro ao atualizar pasta: ${err.message}`);
+          }
+        }
+      }
+    }
+
+    if (choice === 'update') {
+      p.log.info('Você já está na versão mais recente instalada.');
+    }
+
+    if (choice === 'exit') {
+      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,
+      });
+
+      p.outro(pc.cyan('Até logo! O servidor continua em segundo plano.'));
+      process.exit(0);
+    }
+  }
+}

package/src/tunnel-client.js

@@ -0,0 +1,160 @@
+import WebSocket from 'ws';
+import { readConfig } from './config.js';
+
+export class EdgeTunnelClient {
+  constructor() {
+    this.ws = null;
+    this.pingTimer = null;
+    this.reconnectTimer = null;
+    this.isStopping = false;
+  }
+
+  start() {
+    const config = readConfig();
+    if (!config || !config.serverUrl || !config.apiKey) {
+      return;
+    }
+
+    this.isStopping = false;
+    this.connect();
+  }
+
+  stop() {
+    this.isStopping = true;
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {}
+      this.ws = null;
+    }
+  }
+
+  connect() {
+    if (this.isStopping) return;
+
+    const config = readConfig();
+    if (!config) return;
+
+    const base = config.serverUrl.replace(/\/$/, '');
+    const wsProto = base.startsWith('https') ? 'wss' : 'ws';
+    const hostPart = base.replace(/^https?:\/\//, '');
+    const url = `${wsProto}://${hostPart}/api/v1/nodes/tunnel?token=${encodeURIComponent(config.apiKey)}`;
+
+    try {
+      this.ws = new WebSocket(url, {
+        rejectUnauthorized: false,
+        family: 4,
+      });
+
+      this.ws.on('open', () => {
+        // Envia PING a cada 25 segundos
+        if (this.pingTimer) clearInterval(this.pingTimer);
+        this.pingTimer = setInterval(() => {
+          if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ type: 'PING' }));
+          }
+        }, 25000);
+      });
+
+      this.ws.on('message', async (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === 'COMMAND' && msg.correlationId) {
+            await this.handleCloudCommand(msg);
+          }
+        } catch {}
+      });
+
+      this.ws.on('close', () => {
+        if (this.pingTimer) clearInterval(this.pingTimer);
+        this.scheduleReconnect();
+      });
+
+      this.ws.on('error', () => {
+        if (this.pingTimer) clearInterval(this.pingTimer);
+        this.scheduleReconnect();
+      });
+    } catch {
+      this.scheduleReconnect();
+    }
+  }
+
+  scheduleReconnect() {
+    if (this.isStopping) return;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, 5000);
+  }
+
+  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({}),
+        });
+        const jJson = await jRes.json();
+        if (!jRes.ok) throw new Error(jJson?.error?.message || `Falha no comando do trabalho: ${jobAction}`);
+        resultData = jJson.data;
+      }
+
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({
+          type: 'COMMAND_RESPONSE',
+          correlationId: msg.correlationId,
+          data: resultData,
+        }));
+      }
+    } catch (err) {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({
+          type: 'COMMAND_RESPONSE',
+          correlationId: msg.correlationId,
+          error: err.message,
+        }));
+      }
+    }
+  }
+}
+
+export const edgeTunnelClient = new EdgeTunnelClient();