@fabioforest/openclaw 3.0.0

package/lib/setup/config_wizard.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/**
+ * OpenClaw OS - Universal Setup Wizard
+ * 
+ * Orquestrador principal que delega para os módulos lib/:
+ * - detect.js  → detecção de ambiente (Docker/WSL2/Mac/Linux/VPS)
+ * - config.js  → leitura/escrita JSON atômica + defaults
+ * - security.js → tokens, masking e verificação de porta
+ * - channels.js → validação e configuração de canais
+ * 
+ * Princípios:
+ * - Seguro por padrão: bind localhost + auth token
+ * - Cross-platform: detecção automática de ambiente
+ * - Não destrutivo: nunca sobrescreve sem confirmação
+ * 
+ * @module config_wizard
+ * @version 2.0.0
+ * @author OpenClaw DevOps
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+
+// Módulos extraídos para lib/ — cada um com responsabilidade única
+const { detectEnvironment } = require("../detect");
+const { readJsonSafe, writeJsonSafe, ensureFile, initConfigDefaults } = require("../config");
+const { mask, generateToken, portInUse } = require("../security");
+const { supportedChannels, configureChannel } = require("../channels");
+
+/** Interface readline para perguntas interativas */
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+/**
+ * Faz uma pergunta ao usuário via stdin e retorna a resposta trimada.
+ * @param {string} q - A pergunta a ser exibida
+ * @returns {Promise<string>} Resposta do usuário (trimada)
+ */
+function ask(q) { return new Promise(res => rl.question(q, ans => res(ans.trim()))); }
+
+/**
+ * Função principal do wizard de setup.
+ * Orquestra todo o fluxo interativo:
+ * 1. Detecta ambiente
+ * 2. Configura gateway (bind + auth)
+ * 3. Gera/solicita token de autenticação
+ * 4. Sugere sandbox em VPS
+ * 5. Configura canais (Telegram/Discord/WhatsApp)
+ * 6. Configura allowlist de filesystem
+ * 7. Cria arquivos de persistência (MEMORY.md, SOUL.md, AGENTS.md)
+ * 8. Verifica porta 18789
+ * 9. Sugere hardening em VPS
+ * @returns {Promise<void>}
+ */
+async function main() {
+  console.log("\n🧠 OpenClaw OS — Universal Setup Wizard\n");
+
+  // --- 1. Detecção de ambiente (delegado para lib/detect) ---
+  const env = detectEnvironment();
+  console.log(`Ambiente detectado: ${env}`);
+
+  const base = process.cwd();
+  const configPath = path.join(base, "openclaw.json");
+
+  // --- 2. Leitura da configuração existente (delegado para lib/config) ---
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    const parsed = readJsonSafe(configPath);
+    if (!parsed) {
+      console.error("✖ openclaw.json existe mas não é um JSON válido. Corrija e rode novamente.");
+      process.exit(2);
+    }
+    config = parsed;
+  }
+
+  // Inicializa seções padrão sem sobrescrever existentes
+  config = initConfigDefaults(config);
+
+  let needWrite = !fs.existsSync(configPath);
+
+  // --- 3. gateway.bind: segurança por padrão (localhost only) ---
+  const desiredBind = "127.0.0.1";
+  if (config.gateway.bind !== desiredBind) {
+    const ans = await ask(`gateway.bind está "${config.gateway.bind ?? "(vazio)"}". Ajustar para "${desiredBind}"? (y/n): `);
+    if (ans.toLowerCase() === "y") { config.gateway.bind = desiredBind; needWrite = true; }
+  } else {
+    console.log("✔ gateway.bind já está seguro (127.0.0.1)");
+  }
+
+  // --- 4. auth.mode: token obrigatório ---
+  const desiredAuthMode = "token";
+  if (config.auth.mode !== desiredAuthMode) {
+    const ans = await ask(`auth.mode está "${config.auth.mode ?? "(vazio)"}". Ajustar para "${desiredAuthMode}"? (y/n): `);
+    if (ans.toLowerCase() === "y") { config.auth.mode = desiredAuthMode; needWrite = true; }
+  } else {
+    console.log("✔ auth.mode já está em token");
+  }
+
+  // --- 5. Geração de token de autenticação (delegado para lib/security) ---
+  if (config.auth.mode === "token") {
+    config.auth.token = config.auth.token || "";
+    if (!config.auth.token) {
+      const ans = await ask("Nenhum token encontrado. Gerar um token seguro automaticamente? (y/n): ");
+      if (ans.toLowerCase() === "y") {
+        config.auth.token = generateToken();
+        console.log(`✔ Token gerado: ${mask(config.auth.token)} (salvo no openclaw.json)`);
+        needWrite = true;
+      } else {
+        const manual = await ask("Cole um token: ");
+        if (manual) { config.auth.token = manual; needWrite = true; }
+      }
+    } else {
+      console.log(`✔ Token já configurado (${mask(config.auth.token)})`);
+    }
+  }
+
+  // --- 6. Sandbox: sugestão para VPS rodando como root ---
+  if (env === "linux-vps-root") {
+    if (config.sandbox.mode !== "non-main") {
+      const ans = await ask(`Detectei VPS/root. Ativar sandbox mode "non-main" para isolar execuções? (y/n): `);
+      if (ans.toLowerCase() === "y") { config.sandbox.mode = "non-main"; needWrite = true; }
+    }
+  }
+
+  // --- 7. Configuração de canais (delegado para lib/channels) ---
+  console.log("\n📣 Canais (opcional)");
+  const channelList = supportedChannels().join("/");
+  const ch = await ask(`Ativar agora? (${channelList}/nenhum): `);
+  const channelChoice = ch.toLowerCase();
+
+  if (supportedChannels().includes(channelChoice)) {
+    // configureChannel recebe uma função ask injetável (testável)
+    const configured = await configureChannel(config, channelChoice, ask);
+    if (configured) needWrite = true;
+  } else {
+    console.log("↪ Pulando canais.");
+  }
+
+  // --- 8. Filesystem allowlist: princípio do menor privilégio ---
+  console.log("\n📁 Acesso a arquivos locais (mínimo necessário)");
+  console.log("Adicione apenas pastas que o OpenClaw realmente precisa acessar.");
+  const addPath = await ask("Adicionar uma pasta allowlist agora? (caminho ou ENTER para pular): ");
+  if (addPath) {
+    const resolved = addPath.replace(/^~\//, os.homedir() + path.sep);
+    config.filesystem.allowlist.push(resolved);
+    needWrite = true;
+    console.log(`✔ Allowlist adicionada: ${resolved}`);
+  }
+
+  // --- 9. Arquivos de persistência (delegado para lib/config.ensureFile) ---
+  ensureFile(path.join(base, "MEMORY.md"), "# MEMORY.md\n\n- Preferências e notas persistentes do OpenClaw.\n");
+  ensureFile(path.join(base, "SOUL.md"), "# SOUL.md\n\n- Identidade e regras de comportamento (ver AGENTS.md).\n");
+  ensureFile(path.join(base, "AGENTS.md"), "# AGENTS.md\n\nVocê é um SysAdmin Proativo. Use VPN-first, bind localhost e token.\n");
+
+  // --- 10. Checagem de porta (delegado para lib/security.portInUse) ---
+  const port = 18789;
+  console.log("\n🔎 Checagens rápidas");
+  const inUse = await portInUse("127.0.0.1", port);
+  if (inUse) console.log(`ℹ Porta ${port} respondeu em 127.0.0.1 (ok se OpenClaw está rodando).`);
+  else console.log(`ℹ Porta ${port} não respondeu em 127.0.0.1 (ok se ainda não iniciou).`);
+
+  // --- 11. Hardening: recomendações para VPS ---
+  if (env === "linux-vps-root") {
+    console.log("\n🛡 Hardening (recomendado)");
+    console.log("- Crie um usuário não-root (ex: clawuser) e desative login por senha no SSH.");
+    console.log("- Ative firewall (UFW) e fail2ban.");
+    console.log("- Exponha publicamente apenas WireGuard (UDP) se usar VPN.");
+  }
+
+  // --- 12. Persistência da configuração (delegado para lib/config.writeJsonSafe) ---
+  if (needWrite) {
+    writeJsonSafe(configPath, config);
+    console.log("\n✔ openclaw.json atualizado/criado com segurança.");
+  } else {
+    console.log("\n✔ Nenhuma alteração necessária no openclaw.json.");
+  }
+
+  console.log("\n✅ Setup finalizado.");
+  console.log("Próximo passo: configurar VPN (WireGuard) e aplicar policies (skills/openclaw-ops).");
+  rl.close();
+}
+
+main().catch((e) => {
+  console.error("✖ Erro:", e && e.message ? e.message : e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@fabioforest/openclaw",
+  "version": "3.0.0",
+  "description": "CLI e starter kit para configuração segura do OpenClaw em VPS, Mac, Windows e Docker",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "bin/openclaw.js",
+  "bin": {
+    "openclaw": "./bin/openclaw.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "setup": "node lib/setup/config_wizard.js",
+    "docker:build": "docker build -t openclaw -f docker/Dockerfile ."
+  },
+  "keywords": [
+    "openclaw",
+    "agent",
+    "security",
+    "devops",
+    "cli",
+    "wireguard",
+    "vpn",
+    "sysadmin"
+  ],
+  "author": "Fabio Figueiredo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fabioffigueiredo/openclaw-agents"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/templates/.agent/agents/setup-specialist.md

@@ -0,0 +1,24 @@
+---
+name: setup-specialist
+role: Especialista em Instalação e Troubleshooting
+description: Agente focado em resolver problemas de ambiente, rede e dependências durante a instalação do OpenClaw.
+skills:
+  - openclaw-installation-debugger
+personality:
+  tone: Técnico, direto e solícito.
+  style: Prioriza a resolução de erros antes de qualquer outra tarefa.
+---
+
+# Setup Specialist
+
+Você é o especialista designado para garantir que o OpenClaw seja instalado e configurado corretamente. Sua prioridade máxima é identificar e corrigir bloqueios.
+
+## Responsabilidades
+1.  **Diagnosticar**: Usar a skill `openclaw-installation-debugger` para verificar rede, permissões e versões.
+2.  **Corrigir**: Sugerir comandos exatos para resolver problemas (ex: instalar Docker, configurar proxy npm, corrigir permissões).
+3.  **Verificar**: Após a correção, rodar novamente o diagnóstico para confirmar o sucesso.
+
+## Instruções
+- Se o usuário relatar "erro na instalação", execute imediatamente o script `debug.js` da skill `openclaw-installation-debugger`.
+- Analise a saída do script. Se a rede falhar, verifique proxy/firewall. Se permisão falhar, sugira `sudo` ou `chown`.
+- Não tente configurar VPN ou Policies até que o ambiente base esteja saudável (Node, NPM, Docker, Rede).

package/templates/.agent/agents/sysadmin-proativo.md

@@ -0,0 +1,31 @@
+---
+name: sysadmin-proativo
+description: Operador padrão (seguro) para manter OpenClaw saudável e auditável.
+model: default
+---
+
+# Persona
+Você é um SysAdmin proativo e cauteloso. Sua prioridade é **segurança, auditabilidade e estabilidade**.
+
+## Modo de Operação
+- Trabalhe em passos curtos e verificáveis.
+- Prefira runbooks e skills catalogadas.
+- Peça confirmação antes de ações arriscadas ou irreversíveis.
+- Nunca execute comandos fora do escopo do runbook ativo.
+
+## Tools Permitidas
+- `run_command` — apenas para comandos listados nos runbooks ou allowlist
+- `read_file` / `write_file` — dentro dos diretórios autorizados
+- `list_dir` — sem restrição
+- `view_file` — sem restrição
+
+## Limites
+- **Timeout por comando**: 30s (padrão), 120s (operações longas com `--long`)
+- **Retry máximo**: 3 tentativas antes de escalar para humano
+- **Circuit breaker**: Suspende execuções se 2+ falhas consecutivas
+- **Break-glass**: Requer aprovação explícita + auditoria completa
+
+## Comandos Bloqueados (ver hooks/pre-tool-use.js)
+- `rm -rf /`, `mkfs`, `dd if=`, `shutdown`, `reboot`
+- Qualquer comando com `> /dev/sda` ou pipe para dispositivos de bloco
+- `chmod 777`, `chown root` sem aprovação

package/templates/.agent/hooks/pre-tool-use.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Hook PreToolUse — bloqueia comandos destrutivos antes da execução.
+ *
+ * Este hook é chamado pelo agente antes de executar qualquer tool.
+ * Se o comando for considerado perigoso, retorna { blocked: true, reason }.
+ *
+ * Integra-se com a policy de break-glass: se o break-glass estiver ativo
+ * e aprovado, o comando é liberado com auditoria completa.
+ */
+
+// Padrões de comandos destrutivos que requerem bloqueio
+const BLOCKED_PATTERNS = [
+    { pattern: /rm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+)?\/(\s|$)/, reason: "rm -rf / detectado — remoção da raiz bloqueada" },
+    { pattern: /rm\s+-[a-zA-Z]*r[a-zA-Z]*f/, reason: "rm recursivo com force — requer aprovação" },
+    { pattern: /mkfs/, reason: "mkfs — formatação de disco bloqueada" },
+    { pattern: /dd\s+if=/, reason: "dd if= — escrita direta em dispositivo bloqueada" },
+    { pattern: /shutdown/, reason: "shutdown — desligamento requer aprovação humana" },
+    { pattern: /reboot/, reason: "reboot — reinicialização requer aprovação humana" },
+    { pattern: />\s*\/dev\/[sh]d[a-z]/, reason: "Redirecionamento para dispositivo de bloco bloqueado" },
+    { pattern: /chmod\s+777/, reason: "chmod 777 — permissão aberta demais, requer aprovação" },
+    { pattern: /chown\s+root/, reason: "chown root — mudança de proprietário para root requer aprovação" },
+    { pattern: /:(){ :\|:& };:/, reason: "Fork bomb detectada — execução bloqueada" },
+    { pattern: /curl\s+.*\|\s*(ba)?sh/, reason: "Pipe de URL para shell — execução remota bloqueada" },
+    { pattern: /wget\s+.*\|\s*(ba)?sh/, reason: "Pipe de URL para shell — execução remota bloqueada" },
+];
+
+// Lista de diretórios protegidos (não podem ser alvo de write/delete)
+const PROTECTED_PATHS = [
+    "/etc/passwd",
+    "/etc/shadow",
+    "/etc/sudoers",
+    "/boot",
+    "/usr/bin",
+    "/usr/sbin",
+];
+
+/**
+ * Verifica se um comando deve ser bloqueado.
+ * @param {string} command — o comando a ser verificado
+ * @param {object} [options] — opções adicionais
+ * @param {boolean} [options.breakGlassActive] — se break-glass está ativo
+ * @returns {{ blocked: boolean, reason?: string, requiresApproval?: boolean }}
+ */
+function checkCommand(command, options = {}) {
+    if (!command || typeof command !== "string") {
+        return { blocked: false };
+    }
+
+    const normalized = command.trim().toLowerCase();
+
+    // Verifica padrões destrutivos
+    for (const { pattern, reason } of BLOCKED_PATTERNS) {
+        if (pattern.test(command)) {
+            // Se break-glass ativo, permite mas marca como requiring approval
+            if (options.breakGlassActive) {
+                return {
+                    blocked: false,
+                    requiresApproval: true,
+                    reason: `[BREAK-GLASS] ${reason} — liberado com auditoria`,
+                };
+            }
+            return { blocked: true, reason };
+        }
+    }
+
+    // Verifica caminhos protegidos
+    for (const protectedPath of PROTECTED_PATHS) {
+        if (command.includes(protectedPath) && /write|delete|rm|mv|cp.*>/.test(normalized)) {
+            return {
+                blocked: true,
+                reason: `Operação em caminho protegido: ${protectedPath}`,
+            };
+        }
+    }
+
+    return { blocked: false };
+}
+
+/**
+ * Verifica se um caminho de arquivo é seguro para operações de escrita.
+ * @param {string} filePath — caminho do arquivo
+ * @returns {{ allowed: boolean, reason?: string }}
+ */
+function checkFilePath(filePath) {
+    if (!filePath || typeof filePath !== "string") {
+        return { allowed: true };
+    }
+
+    for (const protectedPath of PROTECTED_PATHS) {
+        if (filePath.startsWith(protectedPath)) {
+            return {
+                allowed: false,
+                reason: `Escrita em caminho protegido bloqueada: ${protectedPath}`,
+            };
+        }
+    }
+
+    return { allowed: true };
+}
+
+module.exports = {
+    checkCommand,
+    checkFilePath,
+    BLOCKED_PATTERNS,
+    PROTECTED_PATHS,
+};

package/templates/.agent/rules/SECURITY.md

@@ -0,0 +1,7 @@
+# Guardrails de Segurança (OpenClaw OS)
+- bind localhost (127.0.0.1) por padrão
+- auth token obrigatório
+- VPN-first para acesso remoto
+- bloquear comandos destrutivos (rm -rf, mkfs, dd if=, shutdown/reboot) sem aprovação
+
+Este arquivo é uma referência de políticas para sua integração em hooks (VS Code/Cursor) ou no Policy Engine do OpenClaw core.

package/templates/.agent/skills/openclaw-installation-debugger/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: openclaw-installation-debugger
+description: Diagnóstico profundo de falhas na instalação, conectividade e integridade do OpenClaw. Verifica rede (NPM/GitHub), proxy, versões e integridade de arquivos.
+version: 1.0
+author: Fabioforest
+---
+
+# OpenClaw Installation Debugger
+
+Esta skill fornece ferramentas avançadas para diagnosticar por que uma instalação falhou ou por que o agente não está operando corretamente.
+
+## Scripts Disponíveis
+
+### `debug.js`
+Executa uma bateria de testes detalhados e gera um relatório JSON/Texto.
+
+**Verificações:**
+1.  **Ambiente**: SO, Node.js version, NPM version, Docker (se disponível).
+2.  **Rede**:
+    - Ping para `registry.npmjs.org` (verifica bloqueio de firewall/proxy).
+    - Ping para `github.com`.
+    - Resolução DNS.
+3.  **Instalação**:
+    - Integridade da pasta `.agent/` (arquivos esperados vs encontrados).
+    - Permissões de escrita no diretório atual.
+    - Validade do `openclaw.json` (se existir).
+
+## Como usar
+Execute via CLI (se disponível):
+```bash
+npx @fabioforest/openclaw debug
+```
+
+Ou diretamente via node se estiver debugando o pacote local:
+```bash
+node templates/.agent/skills/openclaw-installation-debugger/scripts/debug.js
+```

package/templates/.agent/skills/openclaw-installation-debugger/scripts/debug.js

@@ -0,0 +1,165 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const dns = require("dns").promises;
+const https = require("https");
+const { execSync } = require("child_process");
+
+/**
+ * Utilitário de log colorido
+ */
+const colors = {
+    reset: "\x1b[0m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    bold: "\x1b[1m"
+};
+
+function log(msg, color = colors.reset) {
+    console.log(`${color}${msg}${colors.reset}`);
+}
+
+function success(msg) { log(`✅ ${msg}`, colors.green); }
+function warn(msg) { log(`⚠️  ${msg}`, colors.yellow); }
+function fail(msg) { log(`❌ ${msg}`, colors.red); }
+function info(msg) { log(`ℹ️  ${msg}`, colors.blue); }
+
+/**
+ * Verifica conectividade HTTP
+ */
+function checkHttp(url) {
+    return new Promise((resolve) => {
+        const req = https.get(url, { timeout: 5000 }, (res) => {
+            if (res.statusCode >= 200 && res.statusCode < 400) {
+                resolve({ ok: true, status: res.statusCode });
+            } else {
+                resolve({ ok: false, status: res.statusCode });
+            }
+        });
+        req.on("error", (err) => resolve({ ok: false, error: err.message }));
+        req.on("timeout", () => { req.destroy(); resolve({ ok: false, error: "timeout" }); });
+    });
+}
+
+async function runDebug() {
+    log("\n🔍 OpenClaw Installation Debugger\n", colors.bold);
+
+    const report = {
+        timestamp: new Date().toISOString(),
+        system: {},
+        network: {},
+        installation: {}
+    };
+
+    // 1. Sistema
+    info("Checando sistema...");
+    try {
+        report.system.platform = os.platform();
+        report.system.release = os.release();
+        report.system.arch = os.arch();
+        report.system.node = process.version;
+
+        try {
+            report.system.npm = execSync("npm -v").toString().trim();
+        } catch (e) { report.system.npm = "não encontrado"; }
+
+        try {
+            execSync("docker -v", { stdio: "ignore" });
+            report.system.docker = "instalado";
+        } catch (e) { report.system.docker = "não encontrado"; }
+
+        success(`Node: ${report.system.node}, NPM: ${report.system.npm}, OS: ${report.system.platform}`);
+    } catch (err) {
+        fail(`Erro ao ler sistema: ${err.message}`);
+    }
+
+    // 2. Rede
+    info("\nChecando rede...");
+
+    // DNS
+    try {
+        await dns.lookup("google.com");
+        success("DNS Resolution: OK");
+        report.network.dns = "ok";
+    } catch (err) {
+        fail(`DNS Resolution falhou: ${err.message}`);
+        report.network.dns = "falhou";
+    }
+
+    // NPM Registry
+    const npmCheck = await checkHttp("https://registry.npmjs.org/");
+    if (npmCheck.ok) {
+        success("NPM Registry (https): OK");
+        report.network.npm = "ok";
+    } else {
+        fail(`NPM Registry inacessível: ${npmCheck.error || npmCheck.status}`);
+        report.network.npm = "falhou";
+        warn("  -> Verifique se há proxy ou firewall bloqueando o NPM.");
+    }
+
+    // GitHub
+    const githubCheck = await checkHttp("https://github.com/");
+    if (githubCheck.ok) {
+        success("GitHub (https): OK");
+        report.network.github = "ok";
+    } else {
+        fail(`GitHub inacessível: ${githubCheck.error || githubCheck.status}`);
+        report.network.github = "falhou";
+    }
+
+    // 3. Instalação Local
+    info("\nChecando instalação local (.agent/)...");
+    const agentDir = path.resolve(".agent");
+    if (fs.existsSync(agentDir)) {
+        success(".agent/ encontrado.");
+        report.installation.found = true;
+
+        // Verificar permissões de escrita
+        try {
+            const testFile = path.join(agentDir, ".perm_check");
+            fs.writeFileSync(testFile, "ok");
+            fs.unlinkSync(testFile);
+            success("Permissão de escrita em .agent/: OK");
+            report.installation.write_perm = "ok";
+        } catch (err) {
+            fail(`Sem permissão de escrita em .agent/: ${err.message}`);
+            report.installation.write_perm = "falhou";
+        }
+
+    } else {
+        warn(".agent/ NÃO encontrado no diretório atual.");
+        report.installation.found = false;
+        info("  -> Execute 'npx @fabioforest/openclaw init' para instalar.");
+    }
+
+    // 4. Configuração Global (npm)
+    info("\nChecando configuração global do NPM...");
+    try {
+        const proxy = execSync("npm config get proxy").toString().trim();
+        const httpsProxy = execSync("npm config get https-proxy").toString().trim();
+        const registry = execSync("npm config get registry").toString().trim();
+
+        if (proxy !== "null") warn(`Proxy HTTP configurado: ${proxy}`);
+        if (httpsProxy !== "null") warn(`Proxy HTTPS configurado: ${httpsProxy}`);
+        success(`Registry atual: ${registry}`);
+    } catch (e) {
+        warn("Não foi possível ler configurações do NPM.");
+    }
+
+    log("\n🏁 Debug concluído.", colors.bold);
+    return report;
+}
+
+// Executar se chamado diretamente
+if (require.main === module) {
+    runDebug().catch(err => {
+        console.error("Erro fatal no debugger:", err);
+        process.exit(1);
+    });
+}
+
+module.exports = { runDebug };

package/templates/.agent/skills/openclaw-ops/01-openclaw-vpn-wireguard/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: openclaw-vpn-wireguard
+description: Provisiona WireGuard entre VPS e hosts para que o OpenClaw opere somente via rede privada. Inclui hardening, checklist e validação.
+version: 1.0
+---
+# Objetivo
+Criar VPN WireGuard (VPN-first). Sem VPN, sem acesso remoto.
+
+# Checklist (alto nível)
+- Instalar WireGuard (VPS e host)
+- Gerar chaves por host (nunca reutilizar)
+- Configurar wg0 na VPS (10.60.0.1/24)
+- Adicionar peers com AllowedIPs /32
+- Validar handshake e ping dentro da VPN
+- Definir procedimento de revogação (remover peer)
+
+# Hardening
+- Expor publicamente apenas UDP do WireGuard
+- Não usar 0.0.0.0/0 por padrão
+- Registrar auditoria de add/remove peer

package/templates/.agent/skills/openclaw-ops/02-openclaw-enroll-host/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: openclaw-enroll-host
+description: Onboarding seguro de host na malha WireGuard + OpenClaw com aprovação humana, identidade e revogação rápida.
+version: 1.0
+---
+# Objetivo
+Registrar host com aprovação e aplicar policy baseline.
+
+# Checklist
+- Gerar host_id + fingerprint
+- Registrar host (pending)
+- Aprovar manualmente
+- Aplicar policy baseline
+- Testar revogação (remover peer WireGuard)

package/templates/.agent/skills/openclaw-ops/03-openclaw-policy-baseline/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: openclaw-policy-baseline
+description: Define RBAC e allowlists (deny-by-default) para execução remota via VPN com break-glass expirável.
+version: 1.0
+---
+# Objetivo
+Políticas antes do poder. Deny-by-default.
+
+# Perfis
+- viewer: leitura
+- operator: runbooks permitidos
+- admin: ações elevadas com confirmação extra e auditoria
+
+# Break-glass
+- janela curta
+- expiração automática
+- alerta e auditoria

package/templates/.agent/skills/openclaw-ops/04-openclaw-remote-exec-runbooks/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: openclaw-remote-exec-runbooks
+description: Estrutura execução remota via VPN usando runbooks idempotentes, com timeout, cancel e trilha auditável.
+version: 1.0
+---
+# Objetivo
+Evitar 'shell solto'. Preferir runbooks nomeados.
+
+# Regras
+- validar entradas
+- capturar stdout/stderr
+- timeout/cancel
+- assinar request (request_id)