@fabioforest/openclaw 3.0.0

package/README.md

@@ -0,0 +1,88 @@
+# OpenClaw OS
+
+CLI e starter kit para configuração segura do OpenClaw em VPS, Mac, Windows e Docker.
+
+## Instalação
+
+```bash
+# Via npx (recomendado)
+npx @fabioforest/openclaw init
+
+# Ou instale globalmente
+npm install -g @fabioforest/openclaw
+openclaw init
+```
+
+## Comandos
+
+| Comando | Descrição |
+|---------|-----------|
+| `openclaw init` | Instala templates `.agent/` no projeto |
+| `openclaw update` | Atualiza templates preservando customizações |
+| `openclaw status` | Mostra status da instalação |
+| `openclaw doctor` | Healthcheck automatizado do ambiente |
+| `openclaw setup` | Roda wizard interativo de configuração |
+
+### Opções
+
+```bash
+openclaw init --force          # Sobrescreve .agent/ existente
+openclaw init --path ./dir     # Instala em diretório específico
+openclaw doctor --quiet        # Saída mínima
+```
+
+## O que é instalado
+
+O comando `init` cria a seguinte estrutura no seu projeto:
+
+```
+.agent/
+├── agents/            # Personas de agente (ex: sysadmin-proativo)
+├── hooks/             # Hooks de segurança (PreToolUse)
+├── rules/             # Guardrails de segurança
+├── skills/
+│   ├── universal-setup/   # Wizard de configuração interativo
+│   └── openclaw-ops/      # 8 skills operacionais
+└── workflows/         # Runbooks e slash commands
+```
+
+### Skills Operacionais
+
+| # | Skill | Descrição |
+|---|-------|-----------|
+| 01 | VPN WireGuard | Provisiona VPN entre VPS e hosts |
+| 02 | Enroll Host | Onboarding com aprovação humana |
+| 03 | Policy Baseline | RBAC + allowlists deny-by-default |
+| 04 | Remote Exec | Runbooks com timeout e auditoria |
+| 05 | File Transfer | Transferência com hash e allowlist |
+| 06 | Audit Logging | Log JSON com redaction de segredos |
+| 07 | Safe Update | Canary + rollback automático |
+| 08 | Healthchecks | Circuit breaker + auto-restart |
+
+## Segurança
+
+- **VPN-first** — sem VPN, sem acesso remoto
+- **bind localhost** + **auth token** por padrão
+- **Hook `pre-tool-use`** — bloqueia comandos destrutivos (`rm -rf`, `mkfs`, `dd`, `shutdown`)
+- **Break-glass** — acesso emergencial com expiração automática
+- **Auditoria** — todos os eventos logados com `request_id`
+
+## Desenvolvimento
+
+```bash
+# Instalar dependências
+npm install
+
+# Rodar testes
+npm test
+
+# Testes com watch
+npm run test:watch
+
+# Coverage
+npm run test:coverage
+```
+
+## Licença
+
+MIT

package/bin/openclaw.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * OpenClaw CLI — Entry point principal.
+ *
+ * Parseia argumentos e despacha para o comando correto.
+ * Sem dependências externas — usa apenas process.argv.
+ *
+ * Comandos:
+ *   init   [--force] [--path <dir>]  Instala templates .agent/ no projeto
+ *   update [--path <dir>]            Atualiza templates preservando customizações
+ *   status [--path <dir>]            Mostra status da instalação
+ *   doctor [--path <dir>]            Healthcheck automatizado
+ *   setup                            Roda wizard interativo
+ *   --help                           Mostra ajuda
+ *   --version                        Mostra versão
+ */
+
+const path = require("path");
+const pkg = require("../package.json");
+
+// Comandos disponíveis e seus módulos
+const COMMANDS = {
+    init: "../lib/cli/init",
+    update: "../lib/cli/update",
+    status: "../lib/cli/status",
+    doctor: "../lib/cli/doctor",
+    debug: "../lib/cli/debug",
+    check: "../lib/cli/orchestrate",
+};
+
+/**
+ * Parseia os argumentos da linha de comando.
+ * @param {string[]} argv — process.argv.slice(2)
+ * @returns {{ command: string|null, flags: object }}
+ */
+function parseArgs(argv) {
+    const flags = {};
+    let command = null;
+
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+
+        if (arg === "--help" || arg === "-h") {
+            flags.help = true;
+        } else if (arg === "--version" || arg === "-v") {
+            flags.version = true;
+        } else if (arg === "--force" || arg === "-f") {
+            flags.force = true;
+        } else if (arg === "--path" || arg === "-p") {
+            // Próximo argumento é o caminho
+            flags.path = argv[++i] || ".";
+        } else if (arg === "--quiet" || arg === "-q") {
+            flags.quiet = true;
+        } else if (!arg.startsWith("-") && !command) {
+            command = arg;
+        }
+    }
+
+    return { command, flags };
+}
+
+/**
+ * Exibe a mensagem de ajuda.
+ */
+function showHelp() {
+    console.log(`
+  🦀 OpenClaw CLI v${pkg.version}
+
+  Uso: openclaw <comando> [opções]
+
+  Comandos:
+    init      Instala templates .agent/ no projeto atual
+    update    Atualiza templates preservando customizações
+    status    Mostra status da instalação
+    doctor    Healthcheck automatizado do ambiente
+    setup     Roda wizard interativo de configuração
+    debug     Diagnóstico avançado de instalação e rede
+    check     Orquestrador inteligente (instala ou repara)
+
+  Opções:
+    --path, -p <dir>   Diretório alvo (padrão: ./)
+    --force, -f        Sobrescreve .agent/ existente (init)
+    --quiet, -q        Saída mínima
+    --help, -h         Mostra esta ajuda
+    --version, -v      Mostra a versão
+
+  Exemplos:
+    npx openclaw init
+    npx openclaw init --force --path ./meu-projeto
+    npx openclaw doctor
+    npx openclaw status
+`);
+}
+
+/**
+ * Ponto de entrada principal.
+ */
+async function main() {
+    const { command, flags } = parseArgs(process.argv.slice(2));
+
+    // Flags globais
+    if (flags.version) {
+        console.log(`openclaw v${pkg.version}`);
+        return;
+    }
+
+    if (flags.help || !command) {
+        showHelp();
+        return;
+    }
+
+    // Resolver caminho de destino
+    const targetPath = path.resolve(flags.path || ".");
+
+    // Comando setup — roda wizard diretamente
+    if (command === "setup") {
+        const wizardPath = path.join(__dirname, "..", "lib", "setup", "config_wizard.js");
+        try {
+            require(wizardPath);
+        } catch (err) {
+            console.error(`❌ Erro ao rodar setup wizard: ${err.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+
+    // Verificar se o comando existe
+    if (!COMMANDS[command]) {
+        console.error(`❌ Comando desconhecido: "${command}"`);
+        console.error(`   Use "openclaw --help" para ver comandos disponíveis.`);
+        process.exit(1);
+    }
+
+    // Carregar e executar o comando
+    try {
+        const commandModule = require(COMMANDS[command]);
+        await commandModule.run({ targetPath, flags });
+    } catch (err) {
+        console.error(`❌ Erro ao executar "${command}": ${err.message}`);
+        if (!flags.quiet) {
+            console.error(err.stack);
+        }
+        process.exit(1);
+    }
+}
+
+main().catch((err) => {
+    console.error("❌ Erro inesperado:", err.message);
+    process.exit(1);
+});

package/lib/channels.js

@@ -0,0 +1,84 @@
+/**
+ * Módulo de configuração de canais de comunicação para o OpenClaw Setup Wizard.
+ * Suporta Telegram, Discord e WhatsApp com validação de formato de token.
+ * 
+ * @module lib/channels
+ */
+
+/**
+ * Mapa de validadores de token por canal.
+ * Cada entrada contém:
+ * - fn: função de validação que retorna boolean
+ * - hint: dica de formato para exibição em caso de erro
+ * @type {Object.<string, {fn: Function, hint: string}>}
+ */
+const CHANNEL_VALIDATORS = {
+    telegram: {
+        fn: (token) => /^\d+:[A-Za-z0-9_-]{20,}$/.test(token),
+        hint: "Formato esperado: 123456789:ABCDefghIJKLMnopqr...",
+    },
+    discord: {
+        fn: (token) => /^[A-Za-z0-9_.-]{50,}$/.test(token),
+        hint: "Token do bot (50+ caracteres alfanuméricos com pontos)",
+    },
+    whatsapp: {
+        fn: (token) => /^[A-Za-z0-9_.-]{20,}$/.test(token),
+        hint: "Token da API WhatsApp Business (20+ caracteres)",
+    },
+};
+
+/**
+ * Lista de canais suportados pelo wizard.
+ * @returns {string[]} Nomes dos canais suportados
+ */
+function supportedChannels() {
+    return Object.keys(CHANNEL_VALIDATORS);
+}
+
+/**
+ * Valida o formato de um token para um canal específico.
+ * @param {string} channelName - Nome do canal ("telegram", "discord", "whatsapp")
+ * @param {string} token - Token a validar
+ * @returns {{ valid: boolean, hint: string }} Resultado da validação com hint
+ */
+function validateToken(channelName, token) {
+    const validator = CHANNEL_VALIDATORS[channelName];
+    if (!validator) return { valid: false, hint: `Canal desconhecido: ${channelName}` };
+    return {
+        valid: validator.fn(token),
+        hint: validator.hint,
+    };
+}
+
+/**
+ * Configura um canal no objeto de configuração.
+ * Solicita token via askFn, valida formato e salva na config.
+ * @param {object} config - Objeto de config do openclaw.json (referência, modificado in-place)
+ * @param {string} channelName - Nome do canal ("telegram", "discord", "whatsapp")
+ * @param {Function} askFn - Função async para perguntar ao usuário (recebe string, retorna string)
+ * @returns {Promise<boolean>} true se o canal foi configurado com sucesso
+ */
+async function configureChannel(config, channelName, askFn) {
+    if (!CHANNEL_VALIDATORS[channelName]) {
+        console.log(`✖ Canal desconhecido: ${channelName}`);
+        return false;
+    }
+
+    const token = await askFn(`${channelName} token: `);
+    if (!token) return false;
+
+    const { valid, hint } = validateToken(channelName, token);
+    if (!valid) {
+        console.log(`⚠ Formato de token inválido. ${hint}`);
+        const force = await askFn("Salvar mesmo assim? (y/n): ");
+        if (force.toLowerCase() !== "y") return false;
+    }
+
+    config.channels = config.channels || {};
+    config.channels[channelName] = { token };
+    const displayName = channelName.charAt(0).toUpperCase() + channelName.slice(1);
+    console.log(`✔ ${displayName} configurado.`);
+    return true;
+}
+
+module.exports = { CHANNEL_VALIDATORS, supportedChannels, validateToken, configureChannel };

package/lib/cli/debug.js

@@ -0,0 +1,12 @@
+const { runDebug } = require("../../templates/.agent/skills/openclaw-installation-debugger/scripts/debug.js");
+
+module.exports = {
+    run: async function ({ targetPath, flags }) {
+        try {
+            await runDebug();
+        } catch (err) {
+            console.error("Erro fatal ao executar debug:", err);
+            process.exit(1);
+        }
+    }
+};

package/lib/cli/doctor.js

@@ -0,0 +1,266 @@
+"use strict";
+
+/**
+ * Comando CLI: doctor
+ *
+ * Healthcheck automatizado que verifica:
+ * - openclaw.json (bind, token, canais)
+ * - Porta 18789 em localhost
+ * - WireGuard handshake (se aplicável)
+ * - Integridade dos arquivos .agent/
+ * - Hook pre-tool-use ativo
+ *
+ * Gera relatório ✅/❌ com sugestões de correção.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { readJsonSafe } = require("../config");
+const { portInUse } = require("../security");
+const { detectEnvironment } = require("../detect");
+
+/**
+ * Resultado individual de um check.
+ * @typedef {{ name: string, status: 'ok'|'warn'|'fail', message: string }} CheckResult
+ */
+
+/**
+ * Verifica a configuração do openclaw.json.
+ * @param {string} configPath — caminho do arquivo
+ * @returns {CheckResult[]}
+ */
+function checkConfig(configPath) {
+    const results = [];
+
+    if (!fs.existsSync(configPath)) {
+        results.push({
+            name: "openclaw.json",
+            status: "fail",
+            message: "Arquivo não encontrado — rode 'openclaw init' primeiro",
+        });
+        return results;
+    }
+
+    const config = readJsonSafe(configPath);
+    if (!config) {
+        results.push({
+            name: "openclaw.json",
+            status: "fail",
+            message: "Arquivo corrompido — não é JSON válido",
+        });
+        return results;
+    }
+
+    // Verificar bind
+    const bind = config.gateway?.bind;
+    if (bind === "127.0.0.1") {
+        results.push({ name: "gateway.bind", status: "ok", message: "127.0.0.1 (localhost)" });
+    } else if (bind === "0.0.0.0") {
+        results.push({
+            name: "gateway.bind",
+            status: "fail",
+            message: "0.0.0.0 — exposto publicamente! Mude para 127.0.0.1",
+        });
+    } else {
+        results.push({
+            name: "gateway.bind",
+            status: "warn",
+            message: bind ? `${bind} — verifique se é intencional` : "não definido",
+        });
+    }
+
+    // Verificar auth token
+    const token = config.auth?.token;
+    if (token && token.length >= 24) {
+        results.push({ name: "auth.token", status: "ok", message: `Token configurado (${token.length} chars)` });
+    } else if (token) {
+        results.push({
+            name: "auth.token",
+            status: "warn",
+            message: `Token curto (${token.length} chars) — mínimo recomendado: 24`,
+        });
+    } else {
+        results.push({
+            name: "auth.token",
+            status: "fail",
+            message: "Token não configurado — rode 'openclaw setup'",
+        });
+    }
+
+    // Verificar auth mode
+    const authMode = config.auth?.mode;
+    if (authMode === "token") {
+        results.push({ name: "auth.mode", status: "ok", message: "token" });
+    } else {
+        results.push({
+            name: "auth.mode",
+            status: "warn",
+            message: authMode ? `${authMode} — recomendado: 'token'` : "não definido",
+        });
+    }
+
+    return results;
+}
+
+/**
+ * Verifica a integridade do diretório .agent/.
+ * @param {string} agentDir — caminho do .agent/
+ * @returns {CheckResult[]}
+ */
+function checkAgentDir(agentDir) {
+    const results = [];
+
+    if (!fs.existsSync(agentDir)) {
+        results.push({
+            name: ".agent/",
+            status: "fail",
+            message: "Diretório não encontrado — rode 'openclaw init'",
+        });
+        return results;
+    }
+
+    // Verificar subdiretórios esperados
+    const expectedDirs = ["agents", "rules", "skills", "workflows"];
+    for (const dir of expectedDirs) {
+        const dirPath = path.join(agentDir, dir);
+        if (fs.existsSync(dirPath)) {
+            const count = fs.readdirSync(dirPath).length;
+            results.push({
+                name: `.agent/${dir}/`,
+                status: "ok",
+                message: `${count} item(ns)`,
+            });
+        } else {
+            results.push({
+                name: `.agent/${dir}/`,
+                status: "warn",
+                message: "Diretório ausente",
+            });
+        }
+    }
+
+    // Verificar hook pre-tool-use
+    const hookPath = path.join(agentDir, "hooks", "pre-tool-use.js");
+    if (fs.existsSync(hookPath)) {
+        results.push({
+            name: "hooks/pre-tool-use",
+            status: "ok",
+            message: "Hook de segurança ativo",
+        });
+    } else {
+        results.push({
+            name: "hooks/pre-tool-use",
+            status: "warn",
+            message: "Hook de segurança não encontrado — comandos destrutivos não serão bloqueados",
+        });
+    }
+
+    return results;
+}
+
+/**
+ * Verifica se a porta 18789 está em uso.
+ * @returns {Promise<CheckResult>}
+ */
+async function checkPort() {
+    try {
+        const inUse = await portInUse(18789, "127.0.0.1");
+        if (inUse) {
+            return { name: "porta 18789", status: "ok", message: "Serviço respondendo em localhost:18789" };
+        }
+        return {
+            name: "porta 18789",
+            status: "warn",
+            message: "Porta livre — serviço OpenClaw pode estar parado",
+        };
+    } catch {
+        return {
+            name: "porta 18789",
+            status: "warn",
+            message: "Não foi possível verificar a porta",
+        };
+    }
+}
+
+/**
+ * Verifica ambiente detectado.
+ * @returns {CheckResult}
+ */
+function checkEnvironment() {
+    const env = detectEnvironment();
+    return {
+        name: "ambiente",
+        status: "ok",
+        message: env || "desconhecido",
+    };
+}
+
+/**
+ * Exibe o relatório de resultados.
+ * @param {CheckResult[]} results — resultados dos checks
+ */
+function printReport(results) {
+    const icons = { ok: "✅", warn: "⚠️", fail: "❌" };
+
+    for (const r of results) {
+        const icon = icons[r.status] || "❓";
+        const padding = " ".repeat(Math.max(0, 22 - r.name.length));
+        console.log(`  ${icon} ${r.name}${padding} ${r.message}`);
+    }
+
+    // Resumo
+    const okCount = results.filter((r) => r.status === "ok").length;
+    const warnCount = results.filter((r) => r.status === "warn").length;
+    const failCount = results.filter((r) => r.status === "fail").length;
+
+    console.log(`\n📊 Resumo: ${okCount} ok, ${warnCount} avisos, ${failCount} erros`);
+
+    if (failCount > 0) {
+        console.log("\n💡 Sugestões:");
+        for (const r of results.filter((r) => r.status === "fail")) {
+            console.log(`   • ${r.name}: ${r.message}`);
+        }
+    }
+}
+
+/**
+ * Executa o comando doctor.
+ * @param {object} options
+ * @param {string} options.targetPath — diretório alvo
+ * @param {object} options.flags — flags do CLI
+ */
+async function run({ targetPath, flags }) {
+    const agentDir = path.join(targetPath, ".agent");
+    const configPath = path.join(targetPath, "openclaw.json");
+
+    if (!flags.quiet) {
+        console.log("\n🩺 OpenClaw Doctor — Diagnóstico do ambiente\n");
+    }
+
+    const results = [];
+
+    // 1. Ambiente
+    results.push(checkEnvironment());
+
+    // 2. Configuração
+    results.push(...checkConfig(configPath));
+
+    // 3. Porta
+    const portResult = await checkPort();
+    results.push(portResult);
+
+    // 4. .agent/
+    results.push(...checkAgentDir(agentDir));
+
+    // Exibir relatório
+    printReport(results);
+    console.log("");
+
+    // Exit code baseado nos resultados
+    const hasFailures = results.some((r) => r.status === "fail");
+    if (hasFailures) {
+        process.exitCode = 1;
+    }
+}
+
+module.exports = { run, checkConfig, checkAgentDir, checkPort, checkEnvironment };