@fabioforest/openclaw 3.0.0

package/lib/ops/policy.js

@@ -0,0 +1,153 @@
+"use strict";
+
+/**
+ * Script operacional: Policy Baseline
+ *
+ * Define RBAC e allowlists (deny-by-default) para execução remota
+ * via VPN com break-glass expirável.
+ *
+ * Referência: skills/openclaw-ops/03-openclaw-policy-baseline/SKILL.md
+ */
+
+const { readJsonSafe, writeJsonSafe } = require("../config");
+
+/**
+ * Perfis RBAC disponíveis com suas permissões.
+ */
+const PROFILES = {
+    viewer: {
+        description: "Somente leitura — pode consultar status e logs",
+        permissions: ["read:status", "read:logs", "read:config"],
+    },
+    operator: {
+        description: "Pode executar runbooks permitidos",
+        permissions: ["read:status", "read:logs", "read:config", "exec:runbook", "write:transfer"],
+    },
+    admin: {
+        description: "Ações elevadas com confirmação extra e auditoria",
+        permissions: [
+            "read:status", "read:logs", "read:config",
+            "exec:runbook", "exec:command", "write:transfer",
+            "write:config", "manage:hosts", "manage:policy",
+        ],
+    },
+};
+
+/**
+ * Verifica se um perfil tem uma determinada permissão.
+ * @param {string} profile — nome do perfil (viewer, operator, admin)
+ * @param {string} permission — permissão a verificar (ex: "exec:runbook")
+ * @returns {boolean}
+ */
+function hasPermission(profile, permission) {
+    const p = PROFILES[profile];
+    if (!p) return false;
+    return p.permissions.includes(permission);
+}
+
+/**
+ * Cria uma sessão break-glass com expiração automática.
+ * @param {string} policyPath — caminho do arquivo de políticas
+ * @param {object} params
+ * @param {string} params.requestedBy — quem solicitou
+ * @param {string} params.reason — motivo do break-glass
+ * @param {number} [params.durationMinutes=15] — duração em minutos
+ * @returns {{ id: string, expiresAt: string }}
+ */
+function createBreakGlass(policyPath, { requestedBy, reason, durationMinutes = 15 }) {
+    const policy = readJsonSafe(policyPath) || { breakGlass: [] };
+
+    const expiresAt = new Date(Date.now() + durationMinutes * 60 * 1000).toISOString();
+    const id = `bg-${Date.now()}`;
+
+    const entry = {
+        id,
+        requestedBy,
+        reason,
+        createdAt: new Date().toISOString(),
+        expiresAt,
+        active: true,
+    };
+
+    if (!policy.breakGlass) policy.breakGlass = [];
+    policy.breakGlass.push(entry);
+    writeJsonSafe(policyPath, policy);
+
+    return { id, expiresAt };
+}
+
+/**
+ * Verifica se existe um break-glass ativo e válido.
+ * @param {string} policyPath — caminho do arquivo de políticas
+ * @returns {{ active: boolean, entry?: object }}
+ */
+function checkBreakGlass(policyPath) {
+    const policy = readJsonSafe(policyPath);
+    if (!policy || !policy.breakGlass) return { active: false };
+
+    const now = new Date();
+    const activeEntry = policy.breakGlass.find(
+        (bg) => bg.active && new Date(bg.expiresAt) > now
+    );
+
+    if (activeEntry) {
+        return { active: true, entry: activeEntry };
+    }
+
+    return { active: false };
+}
+
+/**
+ * Expira todos os break-glass vencidos.
+ * @param {string} policyPath — caminho do arquivo de políticas
+ * @returns {number} quantidade de break-glass expirados
+ */
+function expireBreakGlass(policyPath) {
+    const policy = readJsonSafe(policyPath);
+    if (!policy || !policy.breakGlass) return 0;
+
+    const now = new Date();
+    let count = 0;
+
+    for (const bg of policy.breakGlass) {
+        if (bg.active && new Date(bg.expiresAt) <= now) {
+            bg.active = false;
+            count++;
+        }
+    }
+
+    if (count > 0) writeJsonSafe(policyPath, policy);
+    return count;
+}
+
+/**
+ * Retorna a allowlist de comandos permitidos para um perfil.
+ * @param {string} profile — nome do perfil
+ * @returns {string[]} lista de padrões de comando permitidos
+ */
+function getAllowedCommands(profile) {
+    const allowlists = {
+        viewer: [],
+        operator: [
+            "systemctl status *",
+            "docker ps",
+            "docker compose ps",
+            "wg show *",
+            "ping *",
+            "cat /var/log/*",
+            "tail -f /var/log/*",
+        ],
+        admin: ["*"], // Admin pode tudo (com confirmação)
+    };
+
+    return allowlists[profile] || [];
+}
+
+module.exports = {
+    PROFILES,
+    hasPermission,
+    createBreakGlass,
+    checkBreakGlass,
+    expireBreakGlass,
+    getAllowedCommands,
+};

package/lib/ops/transfer.js

@@ -0,0 +1,152 @@
+"use strict";
+
+/**
+ * Script operacional: File Transfer Safe
+ *
+ * Transferência de arquivos via VPN com allowlist de diretórios,
+ * hashing, limites de tamanho e auditoria.
+ *
+ * Referência: skills/openclaw-ops/05-openclaw-file-transfer-safe/SKILL.md
+ */
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+// Tamanho máximo padrão: 50MB
+const DEFAULT_MAX_SIZE = 50 * 1024 * 1024;
+
+/**
+ * Calcula o SHA-256 de um arquivo.
+ * @param {string} filePath — caminho do arquivo
+ * @returns {string} hash hex
+ */
+function hashFile(filePath) {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Verifica se um caminho está dentro da allowlist.
+ * @param {string} filePath — caminho do arquivo
+ * @param {string[]} allowedDirs — diretórios permitidos
+ * @returns {{ allowed: boolean, reason?: string }}
+ */
+function checkAllowlist(filePath, allowedDirs) {
+    const resolved = path.resolve(filePath);
+
+    for (const dir of allowedDirs) {
+        const resolvedDir = path.resolve(dir);
+        if (resolved.startsWith(resolvedDir + path.sep) || resolved === resolvedDir) {
+            return { allowed: true };
+        }
+    }
+
+    return {
+        allowed: false,
+        reason: `Caminho '${resolved}' fora da allowlist de diretórios`,
+    };
+}
+
+/**
+ * Verifica se o arquivo não excede o tamanho máximo.
+ * @param {string} filePath — caminho do arquivo
+ * @param {number} [maxSize] — tamanho máximo em bytes
+ * @returns {{ allowed: boolean, size: number, reason?: string }}
+ */
+function checkFileSize(filePath, maxSize = DEFAULT_MAX_SIZE) {
+    const stats = fs.statSync(filePath);
+    if (stats.size > maxSize) {
+        const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+        const maxMB = (maxSize / 1024 / 1024).toFixed(2);
+        return {
+            allowed: false,
+            size: stats.size,
+            reason: `Arquivo (${sizeMB}MB) excede o limite de ${maxMB}MB`,
+        };
+    }
+    return { allowed: true, size: stats.size };
+}
+
+/**
+ * Executa transferência segura de arquivo com validações.
+ * @param {object} params
+ * @param {string} params.source — caminho do arquivo fonte
+ * @param {string} params.destination — caminho do destino
+ * @param {string[]} params.allowedDirs — diretórios permitidos
+ * @param {number} [params.maxSize] — tamanho máximo em bytes
+ * @param {string} params.operator — quem está fazendo a transferência
+ * @returns {{ success: boolean, auditEntry: object, error?: string }}
+ */
+function transferFile({ source, destination, allowedDirs, maxSize, operator }) {
+    const auditEntry = {
+        action: "file.transfer",
+        operator,
+        source: path.resolve(source),
+        destination: path.resolve(destination),
+        timestamp: new Date().toISOString(),
+        hashBefore: null,
+        hashAfter: null,
+        size: null,
+        success: false,
+    };
+
+    // 1. Verificar se o arquivo fonte existe
+    if (!fs.existsSync(source)) {
+        auditEntry.error = "Arquivo fonte não encontrado";
+        return { success: false, auditEntry, error: auditEntry.error };
+    }
+
+    // 2. Verificar allowlist para fonte e destino
+    const srcCheck = checkAllowlist(source, allowedDirs);
+    if (!srcCheck.allowed) {
+        auditEntry.error = `Fonte: ${srcCheck.reason}`;
+        return { success: false, auditEntry, error: auditEntry.error };
+    }
+
+    const destCheck = checkAllowlist(destination, allowedDirs);
+    if (!destCheck.allowed) {
+        auditEntry.error = `Destino: ${destCheck.reason}`;
+        return { success: false, auditEntry, error: auditEntry.error };
+    }
+
+    // 3. Verificar tamanho
+    const sizeCheck = checkFileSize(source, maxSize);
+    if (!sizeCheck.allowed) {
+        auditEntry.error = sizeCheck.reason;
+        auditEntry.size = sizeCheck.size;
+        return { success: false, auditEntry, error: auditEntry.error };
+    }
+    auditEntry.size = sizeCheck.size;
+
+    // 4. Hash antes da cópia
+    auditEntry.hashBefore = hashFile(source);
+
+    // 5. Copiar o arquivo
+    const destDir = path.dirname(destination);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    fs.copyFileSync(source, destination);
+
+    // 6. Hash depois da cópia (verificar integridade)
+    auditEntry.hashAfter = hashFile(destination);
+
+    if (auditEntry.hashBefore !== auditEntry.hashAfter) {
+        auditEntry.error = "Integridade comprometida: hash pré/pós não confere";
+        // Remove arquivo corrompido
+        fs.unlinkSync(destination);
+        return { success: false, auditEntry, error: auditEntry.error };
+    }
+
+    auditEntry.success = true;
+    return { success: true, auditEntry };
+}
+
+module.exports = {
+    hashFile,
+    checkAllowlist,
+    checkFileSize,
+    transferFile,
+    DEFAULT_MAX_SIZE,
+};

package/lib/ops/update-safe.js

@@ -0,0 +1,173 @@
+"use strict";
+
+/**
+ * Script operacional: Safe Update
+ *
+ * Atualização segura com verificação (hash/assinatura),
+ * canary e rollback automático.
+ *
+ * Referência: skills/openclaw-ops/07-openclaw-safe-update/SKILL.md
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const crypto = require("crypto");
+
+/**
+ * Cria um snapshot de backup antes do update.
+ * @param {string} targetDir — diretório a fazer backup
+ * @param {string} backupDir — diretório de backups
+ * @returns {{ backupPath: string, timestamp: string }}
+ */
+function createSnapshot(targetDir, backupDir) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = path.join(backupDir, `snapshot-${timestamp}`);
+
+    if (!fs.existsSync(backupDir)) {
+        fs.mkdirSync(backupDir, { recursive: true });
+    }
+
+    // Cópia recursiva do diretório
+    copyDirRecursive(targetDir, backupPath);
+
+    return { backupPath, timestamp };
+}
+
+/**
+ * Copia diretório recursivamente.
+ * @param {string} src — fonte
+ * @param {string} dest — destino
+ */
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+/**
+ * Restaura um snapshot (rollback).
+ * @param {string} backupPath — caminho do backup
+ * @param {string} targetDir — diretório alvo para restaurar
+ * @returns {{ success: boolean, error?: string }}
+ */
+function rollback(backupPath, targetDir) {
+    try {
+        if (!fs.existsSync(backupPath)) {
+            return { success: false, error: `Backup não encontrado: ${backupPath}` };
+        }
+
+        // Remove o diretório atual
+        fs.rmSync(targetDir, { recursive: true, force: true });
+
+        // Restaura do backup
+        copyDirRecursive(backupPath, targetDir);
+
+        return { success: true };
+    } catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+
+/**
+ * Verifica hash de integridade de um arquivo/diretório.
+ * @param {string} filePath — caminho do arquivo
+ * @param {string} expectedHash — hash SHA-256 esperado
+ * @returns {{ valid: boolean, actualHash: string }}
+ */
+function verifyHash(filePath, expectedHash) {
+    const content = fs.readFileSync(filePath);
+    const actualHash = crypto.createHash("sha256").update(content).digest("hex");
+    return { valid: actualHash === expectedHash, actualHash };
+}
+
+/**
+ * Executa um healthcheck pós-update.
+ * @param {object} [checks] — funções de verificação customizáveis
+ * @param {function} [checks.configValid] — verifica se config é válida
+ * @param {function} [checks.serviceRunning] — verifica se serviço está rodando
+ * @returns {{ healthy: boolean, results: object[] }}
+ */
+function postUpdateHealthcheck(checks = {}) {
+    const results = [];
+
+    // Check 1: Configuração válida
+    if (checks.configValid) {
+        try {
+            const ok = checks.configValid();
+            results.push({ name: "config", status: ok ? "ok" : "fail" });
+        } catch (err) {
+            results.push({ name: "config", status: "fail", error: err.message });
+        }
+    }
+
+    // Check 2: Serviço rodando
+    if (checks.serviceRunning) {
+        try {
+            const ok = checks.serviceRunning();
+            results.push({ name: "service", status: ok ? "ok" : "fail" });
+        } catch (err) {
+            results.push({ name: "service", status: "fail", error: err.message });
+        }
+    }
+
+    const healthy = results.every((r) => r.status === "ok");
+    return { healthy, results };
+}
+
+/**
+ * Fluxo completo de safe update com canary e rollback.
+ * @param {object} params
+ * @param {string} params.targetDir — diretório a atualizar
+ * @param {string} params.backupDir — diretório de backups
+ * @param {function} params.applyUpdate — função que aplica o update
+ * @param {object} [params.healthchecks] — funções de verificação
+ * @returns {{ success: boolean, backup: string, error?: string }}
+ */
+async function safeUpdate({ targetDir, backupDir, applyUpdate, healthchecks = {} }) {
+    // 1. Snapshot/backup
+    const { backupPath } = createSnapshot(targetDir, backupDir);
+
+    // 2. Aplicar update
+    try {
+        await applyUpdate();
+    } catch (err) {
+        // Rollback imediato
+        rollback(backupPath, targetDir);
+        return { success: false, backup: backupPath, error: `Update falhou: ${err.message}. Rollback aplicado.` };
+    }
+
+    // 3. Healthcheck pós-update
+    const health = postUpdateHealthcheck(healthchecks);
+
+    if (!health.healthy) {
+        // Rollback automático
+        rollback(backupPath, targetDir);
+        const failedChecks = health.results.filter((r) => r.status === "fail").map((r) => r.name);
+        return {
+            success: false,
+            backup: backupPath,
+            error: `Healthcheck falhou (${failedChecks.join(", ")}). Rollback aplicado.`,
+        };
+    }
+
+    return { success: true, backup: backupPath };
+}
+
+module.exports = {
+    createSnapshot,
+    rollback,
+    verifyHash,
+    postUpdateHealthcheck,
+    safeUpdate,
+};

package/lib/ops/vpn.js

@@ -0,0 +1,131 @@
+"use strict";
+
+/**
+ * Script operacional: VPN WireGuard
+ *
+ * Provisiona e verifica WireGuard entre VPS e hosts.
+ * Princípio: sem VPN, sem acesso remoto.
+ *
+ * Referência: skills/openclaw-ops/01-openclaw-vpn-wireguard/SKILL.md
+ */
+
+const { execSync } = require("child_process");
+const crypto = require("crypto");
+
+/**
+ * Verifica se o WireGuard está instalado.
+ * @returns {{ installed: boolean, version?: string }}
+ */
+function checkInstalled() {
+    try {
+        const output = execSync("wg --version", { encoding: "utf8", timeout: 5000 }).trim();
+        return { installed: true, version: output };
+    } catch {
+        return { installed: false };
+    }
+}
+
+/**
+ * Verifica o status da interface WireGuard (wg0).
+ * @returns {{ active: boolean, peers: number, latestHandshake?: string }}
+ */
+function getInterfaceStatus() {
+    try {
+        const output = execSync("wg show wg0", { encoding: "utf8", timeout: 5000 });
+        const peers = (output.match(/peer:/g) || []).length;
+        const handshakeMatch = output.match(/latest handshake:\s*(.+)/);
+
+        return {
+            active: true,
+            peers,
+            latestHandshake: handshakeMatch ? handshakeMatch[1].trim() : undefined,
+        };
+    } catch {
+        return { active: false, peers: 0 };
+    }
+}
+
+/**
+ * Gera par de chaves WireGuard.
+ * @returns {{ privateKey: string, publicKey: string }}
+ */
+function generateKeyPair() {
+    try {
+        const privateKey = execSync("wg genkey", { encoding: "utf8", timeout: 5000 }).trim();
+        const publicKey = execSync(`echo "${privateKey}" | wg pubkey`, {
+            encoding: "utf8",
+            timeout: 5000,
+            shell: true,
+        }).trim();
+        return { privateKey, publicKey };
+    } catch {
+        // Fallback: gera chaves com crypto (para ambientes sem wg)
+        const key = crypto.randomBytes(32);
+        return {
+            privateKey: key.toString("base64"),
+            publicKey: crypto.createHash("sha256").update(key).digest("base64"),
+        };
+    }
+}
+
+/**
+ * Gera configuração WireGuard para a VPS (servidor).
+ * @param {object} params
+ * @param {string} params.privateKey — chave privada do servidor
+ * @param {string} params.listenPort — porta UDP (padrão: 51820)
+ * @param {string} params.address — endereço IP da VPN (padrão: 10.60.0.1/24)
+ * @returns {string} conteúdo do arquivo wg0.conf
+ */
+function generateServerConfig({ privateKey, listenPort = "51820", address = "10.60.0.1/24" }) {
+    return `[Interface]
+Address = ${address}
+ListenPort = ${listenPort}
+PrivateKey = ${privateKey}
+
+# PostUp/PostDown para firewall (ajuste conforme sua interface de rede)
+# PostUp = iptables -A FORWARD -i wg0 -j ACCEPT
+# PostDown = iptables -D FORWARD -i wg0 -j ACCEPT
+`;
+}
+
+/**
+ * Gera configuração de peer para adicionar à VPS.
+ * @param {object} params
+ * @param {string} params.publicKey — chave pública do peer
+ * @param {string} params.allowedIPs — IPs permitidos (ex: 10.60.0.2/32)
+ * @returns {string} bloco [Peer] para wg0.conf
+ */
+function generatePeerBlock({ publicKey, allowedIPs }) {
+    return `
+[Peer]
+PublicKey = ${publicKey}
+AllowedIPs = ${allowedIPs}
+`;
+}
+
+/**
+ * Valida conectividade dentro da VPN via ping.
+ * @param {string} ip — IP para pingar (ex: 10.60.0.1)
+ * @returns {{ reachable: boolean, latency?: string }}
+ */
+function validateConnectivity(ip) {
+    try {
+        const output = execSync(`ping -c 2 -W 3 ${ip}`, { encoding: "utf8", timeout: 10000 });
+        const latencyMatch = output.match(/time=(\d+\.?\d*)/);
+        return {
+            reachable: true,
+            latency: latencyMatch ? `${latencyMatch[1]}ms` : undefined,
+        };
+    } catch {
+        return { reachable: false };
+    }
+}
+
+module.exports = {
+    checkInstalled,
+    getInterfaceStatus,
+    generateKeyPair,
+    generateServerConfig,
+    generatePeerBlock,
+    validateConnectivity,
+};

package/lib/security.js

@@ -0,0 +1,48 @@
+/**
+ * Módulo de segurança para o OpenClaw Setup Wizard.
+ * Contém verificação de portas, mascaramento de segredos e geração de tokens.
+ * 
+ * @module lib/security
+ */
+const crypto = require("crypto");
+const net = require("net");
+
+/**
+ * Verifica se uma porta está em uso em um host específico.
+ * Usa timeout curto (600ms) para não travar o wizard.
+ * @param {string} host - Endereço do host (ex: "127.0.0.1")
+ * @param {number} port - Número da porta
+ * @returns {Promise<boolean>} true se a porta respondeu (em uso)
+ */
+function portInUse(host, port) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        socket.setTimeout(600);
+        socket.once("error", () => resolve(false));
+        socket.once("timeout", () => { socket.destroy(); resolve(false); });
+        socket.connect(port, host, () => { socket.end(); resolve(true); });
+    });
+}
+
+/**
+ * Mascara um segredo para exibição segura (logs/console).
+ * Mostra apenas os 3 primeiros e 3 últimos caracteres.
+ * @param {string} s - String secreta a ser mascarada
+ * @returns {string} String mascarada (ex: "abc…xyz") ou "***" se curta
+ */
+function mask(s) {
+    if (!s) return "";
+    if (s.length <= 6) return "***";
+    return s.slice(0, 3) + "…" + s.slice(-3);
+}
+
+/**
+ * Gera um token de autenticação seguro usando crypto.randomBytes.
+ * Produz 48 caracteres hexadecimais (24 bytes de entropia).
+ * @returns {string} Token hexadecimal de 48 caracteres
+ */
+function generateToken() {
+    return crypto.randomBytes(24).toString("hex");
+}
+
+module.exports = { portInUse, mask, generateToken };