@fabioforest/openclaw 3.0.0

package/lib/cli/init.js

@@ -0,0 +1,145 @@
+"use strict";
+
+/**
+ * Comando CLI: init
+ *
+ * Copia templates/.agent/ para o diretório destino.
+ * Verifica se .agent/ já existe (bloqueia sem --force).
+ * Cria openclaw.json com defaults via lib/config.js.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { initConfigDefaults, writeJsonSafe } = require("../config");
+
+// Caminho dos templates incluídos no pacote
+const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
+
+/**
+ * Copia diretório recursivamente.
+ * @param {string} src — diretório fonte
+ * @param {string} dest — diretório destino
+ * @param {object} [stats] — contador de arquivos copiados
+ * @returns {object} stats com { files, dirs }
+ */
+function copyDirRecursive(src, dest, stats = { files: 0, dirs: 0 }) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+        stats.dirs++;
+    }
+
+    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, stats);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+            stats.files++;
+        }
+    }
+
+    return stats;
+}
+
+/**
+ * Executa o comando init.
+ * @param {object} options
+ * @param {string} options.targetPath — diretório alvo
+ * @param {object} options.flags — flags do CLI (force, quiet)
+ */
+async function run({ targetPath, flags }) {
+    const agentDir = path.join(targetPath, ".agent");
+    const configPath = path.join(targetPath, "openclaw.json");
+
+    // Verificar se já existe
+    if (fs.existsSync(agentDir) && !flags.force) {
+        console.error("❌ Diretório .agent/ já existe.");
+        console.error("   Use --force para sobrescrever ou 'openclaw update' para atualizar.");
+        process.exit(1);
+    }
+
+    // Verificar se templates existem
+    if (!fs.existsSync(TEMPLATES_DIR)) {
+        console.error("❌ Templates não encontrados. Pacote pode estar corrompido.");
+        process.exit(1);
+    }
+
+    if (!flags.quiet) {
+        console.log("🦀 OpenClaw — Inicializando projeto...\n");
+    }
+
+    // Se --force e já existe, alertar
+    if (fs.existsSync(agentDir) && flags.force) {
+        if (!flags.quiet) {
+            console.log("⚠️  --force: substituindo .agent/ existente\n");
+        }
+        fs.rmSync(agentDir, { recursive: true, force: true });
+    }
+
+    // Copiar templates
+    const stats = copyDirRecursive(TEMPLATES_DIR, agentDir);
+
+    if (!flags.quiet) {
+        console.log(`✅ .agent/ instalado com sucesso!`);
+        console.log(`   📁 ${stats.dirs} diretórios criados`);
+        console.log(`   📄 ${stats.files} arquivos copiados\n`);
+    }
+
+    // Criar openclaw.json com defaults (se não existir)
+    if (!fs.existsSync(configPath)) {
+        const defaults = initConfigDefaults({});
+        writeJsonSafe(configPath, defaults);
+
+        if (!flags.quiet) {
+            console.log("📋 openclaw.json criado com configurações padrão\n");
+        }
+    } else if (!flags.quiet) {
+        console.log("📋 openclaw.json já existe — mantido\n");
+    }
+
+    // Resumo final
+    if (!flags.quiet) {
+        console.log("📂 Estrutura instalada:");
+        listInstalledStructure(agentDir, "   ");
+
+        console.log("\n🚀 Próximos passos:");
+        console.log("   1. openclaw setup    — configurar ambiente");
+        console.log("   2. openclaw doctor   — verificar saúde");
+        console.log("   3. openclaw status   — ver status\n");
+    }
+}
+
+/**
+ * Lista a estrutura instalada de forma visual.
+ * @param {string} dir — diretório para listar
+ * @param {string} prefix — prefixo para indentação
+ */
+function listInstalledStructure(dir, prefix = "") {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+        .sort((a, b) => {
+            // Diretórios primeiro, depois arquivos
+            if (a.isDirectory() && !b.isDirectory()) return -1;
+            if (!a.isDirectory() && b.isDirectory()) return 1;
+            return a.name.localeCompare(b.name);
+        });
+
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const isLast = i === entries.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        const icon = entry.isDirectory() ? "📁" : "📄";
+
+        console.log(`${prefix}${connector}${icon} ${entry.name}`);
+
+        if (entry.isDirectory()) {
+            const childPrefix = prefix + (isLast ? "    " : "│   ");
+            listInstalledStructure(path.join(dir, entry.name), childPrefix);
+        }
+    }
+}
+
+module.exports = { run, copyDirRecursive };

package/lib/cli/orchestrate.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const initCmd = require("./init");
+const doctorCmd = require("./doctor");
+const debugCmd = require("./debug");
+
+module.exports = {
+    run: async function ({ targetPath, flags }) {
+        const agentDir = path.join(targetPath, ".agent");
+
+        console.log("\n🤖 OpenClaw Auto-Orchestrator\n");
+
+        if (!fs.existsSync(agentDir)) {
+            console.log("⚠️  Instalação não encontrada.");
+            console.log("🚀 Iniciando processo de instalação (init)...");
+
+            // Repassa flags, força path atual
+            await initCmd.run({ targetPath, flags });
+            return;
+        }
+
+        console.log("✅ Instalação detectada.");
+        console.log("🏥 Executando verificação de saúde (doctor)...");
+
+        try {
+            // Doctor lança erro ou exit(1) se falhar? 
+            // Precisamos capturar o exit code do doctor se ele for desenhado para matar o processo.
+            // O doctor atual usa exit(1) em erros críticos ou apenas loga?
+            // Vamos checar o doctor depois. Por enquanto, assumimos que ele roda.
+
+            await doctorCmd.run({ targetPath, flags });
+
+            console.log("\n✨ Sistema parece saudável.");
+        } catch (err) {
+            console.log("\n❌ Doctor encontrou problemas ou falhou.");
+            console.log("🔍 Iniciando diagnóstico avançado (debug)...");
+
+            await debugCmd.run({ targetPath, flags });
+        }
+    }
+};

package/lib/cli/status.js

@@ -0,0 +1,128 @@
+"use strict";
+
+/**
+ * Comando CLI: status
+ *
+ * Mostra status da instalação do OpenClaw no projeto.
+ * Verifica presença de .agent/, openclaw.json, lista componentes
+ * e exibe configuração ativa sem revelar tokens.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { readJsonSafe } = require("../config");
+const { mask } = require("../security");
+
+const pkg = require("../../package.json");
+
+/**
+ * Conta arquivos em um diretório recursivamente.
+ * @param {string} dir — diretório para contar
+ * @returns {number} contagem de arquivos
+ */
+function countFiles(dir) {
+    if (!fs.existsSync(dir)) return 0;
+    let count = 0;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            count += countFiles(path.join(dir, entry.name));
+        } else {
+            count++;
+        }
+    }
+    return count;
+}
+
+/**
+ * Lista itens de um diretório (primeiro nível).
+ * @param {string} dir — diretório para listar
+ * @returns {string[]} nomes dos itens
+ */
+function listItems(dir) {
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name);
+}
+
+/**
+ * Executa o comando status.
+ * @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");
+
+    console.log(`\n🦀 OpenClaw Status — v${pkg.version}\n`);
+    console.log(`📂 Projeto: ${targetPath}\n`);
+
+    // Verificar .agent/
+    const agentExists = fs.existsSync(agentDir);
+    console.log(`${agentExists ? "✅" : "❌"} .agent/            ${agentExists ? "instalado" : "não encontrado"}`);
+
+    if (agentExists) {
+        // Listar componentes instalados
+        const skillsDir = path.join(agentDir, "skills");
+        const agentsDir = path.join(agentDir, "agents");
+        const rulesDir = path.join(agentDir, "rules");
+        const workflowsDir = path.join(agentDir, "workflows");
+        const hooksDir = path.join(agentDir, "hooks");
+
+        const skills = listItems(skillsDir);
+        const agentFiles = fs.existsSync(agentsDir)
+            ? fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md"))
+            : [];
+        const ruleFiles = fs.existsSync(rulesDir)
+            ? fs.readdirSync(rulesDir).filter((f) => f.endsWith(".md"))
+            : [];
+        const workflowFiles = fs.existsSync(workflowsDir)
+            ? fs.readdirSync(workflowsDir).filter((f) => f.endsWith(".md"))
+            : [];
+        const hookFiles = fs.existsSync(hooksDir)
+            ? fs.readdirSync(hooksDir).filter((f) => f.endsWith(".js"))
+            : [];
+
+        console.log(`\n📦 Componentes instalados:`);
+        console.log(`   Skills:     ${skills.length > 0 ? skills.join(", ") : "nenhuma"}`);
+        console.log(`   Agents:     ${agentFiles.length > 0 ? agentFiles.map((f) => f.replace(".md", "")).join(", ") : "nenhum"}`);
+        console.log(`   Rules:      ${ruleFiles.length > 0 ? ruleFiles.map((f) => f.replace(".md", "")).join(", ") : "nenhuma"}`);
+        console.log(`   Workflows:  ${workflowFiles.length > 0 ? workflowFiles.map((f) => f.replace(".md", "")).join(", ") : "nenhum"}`);
+        console.log(`   Hooks:      ${hookFiles.length > 0 ? hookFiles.join(", ") : "nenhum"}`);
+        console.log(`   Total:      ${countFiles(agentDir)} arquivos`);
+    }
+
+    // Verificar openclaw.json
+    const configExists = fs.existsSync(configPath);
+    console.log(`\n${configExists ? "✅" : "❌"} openclaw.json      ${configExists ? "encontrado" : "não encontrado"}`);
+
+    if (configExists) {
+        const config = readJsonSafe(configPath);
+        if (config) {
+            console.log(`\n⚙️  Configuração ativa:`);
+            console.log(`   bind:       ${config.gateway?.bind || "não definido"}`);
+            console.log(`   auth.mode:  ${config.auth?.mode || "não definido"}`);
+            console.log(`   token:      ${config.auth?.token ? mask(config.auth.token) : "não definido"}`);
+
+            // Canais configurados
+            const channels = config.channels || {};
+            const activeChannels = Object.entries(channels)
+                .filter(([, v]) => v && v.token)
+                .map(([k]) => k);
+            console.log(`   canais:     ${activeChannels.length > 0 ? activeChannels.join(", ") : "nenhum"}`);
+
+            // Ambiente
+            if (config.environment) {
+                console.log(`   ambiente:   ${config.environment}`);
+            }
+        } else {
+            console.log("   ⚠️  Erro ao ler openclaw.json — arquivo pode estar corrompido");
+        }
+    }
+
+    console.log("");
+}
+
+module.exports = { run };

package/lib/cli/update.js

@@ -0,0 +1,122 @@
+"use strict";
+
+/**
+ * Comando CLI: update
+ *
+ * Atualiza templates .agent/ preservando customizações do usuário.
+ * Compara arquivos por hash SHA-256 e só sobrescreve se:
+ * - O arquivo não foi customizado pelo usuário (hash original)
+ * - Ou se o template tem uma versão mais nova
+ */
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+// Caminho dos templates incluídos no pacote
+const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
+
+/**
+ * Calcula o SHA-256 de um arquivo.
+ * @param {string} filePath — caminho do arquivo
+ * @returns {string} hash em hex
+ */
+function fileHash(filePath) {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Compara e atualiza um diretório recursivamente.
+ * @param {string} src — diretório fonte (template)
+ * @param {string} dest — diretório destino (instalado)
+ * @param {object} stats — contadores { updated, skipped, added }
+ */
+function updateDirRecursive(src, dest, stats) {
+    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()) {
+            updateDirRecursive(srcPath, destPath, stats);
+        } else {
+            if (!fs.existsSync(destPath)) {
+                // Arquivo novo — copiar
+                fs.copyFileSync(srcPath, destPath);
+                stats.added.push(path.relative(dest, destPath) || entry.name);
+            } else {
+                // Arquivo já existe — comparar hashes
+                const srcHash = fileHash(srcPath);
+                const destHash = fileHash(destPath);
+
+                if (srcHash === destHash) {
+                    // Idêntico — nada a fazer
+                    stats.skipped.push(path.relative(dest, destPath) || entry.name);
+                } else {
+                    // Diferente — arquivo foi customizado ou template atualizado
+                    // Preserva o original do usuário fazendo backup
+                    const backupPath = destPath + ".bak";
+                    fs.copyFileSync(destPath, backupPath);
+                    fs.copyFileSync(srcPath, destPath);
+                    stats.updated.push(path.relative(dest, destPath) || entry.name);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Executa o comando update.
+ * @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");
+
+    if (!fs.existsSync(agentDir)) {
+        console.error("❌ Diretório .agent/ não encontrado.");
+        console.error("   Rode 'openclaw init' primeiro para instalar os templates.");
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(TEMPLATES_DIR)) {
+        console.error("❌ Templates não encontrados. Pacote pode estar corrompido.");
+        process.exit(1);
+    }
+
+    if (!flags.quiet) {
+        console.log("\n🔄 OpenClaw Update — Atualizando templates...\n");
+    }
+
+    const stats = { updated: [], skipped: [], added: [] };
+    updateDirRecursive(TEMPLATES_DIR, agentDir, stats);
+
+    if (!flags.quiet) {
+        if (stats.added.length > 0) {
+            console.log(`📄 Novos (${stats.added.length}):`);
+            stats.added.forEach((f) => console.log(`   + ${f}`));
+        }
+
+        if (stats.updated.length > 0) {
+            console.log(`\n🔄 Atualizados (${stats.updated.length}):`);
+            stats.updated.forEach((f) => console.log(`   ~ ${f} (backup: ${f}.bak)`));
+        }
+
+        if (stats.skipped.length > 0) {
+            console.log(`\n⏭️  Sem alteração (${stats.skipped.length}):`);
+            stats.skipped.forEach((f) => console.log(`   = ${f}`));
+        }
+
+        const total = stats.added.length + stats.updated.length;
+        console.log(`\n✅ Update concluído: ${total} alterações, ${stats.skipped.length} mantidos\n`);
+    }
+}
+
+module.exports = { run, updateDirRecursive, fileHash };

package/lib/config.js

@@ -0,0 +1,68 @@
+/**
+ * Módulo de manipulação de configuração (JSON) para o OpenClaw Setup Wizard.
+ * Oferece leitura/escrita atômica de JSON e criação idempotente de arquivos.
+ * 
+ * @module lib/config
+ */
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Lê e parseia um arquivo JSON de forma segura.
+ * Retorna null se o arquivo não existir ou não for JSON válido.
+ * @param {string} filePath - Caminho absoluto do arquivo JSON
+ * @returns {object|null} Objeto parseado ou null em caso de erro
+ */
+function readJsonSafe(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Escreve um objeto como JSON de forma atômica (write-then-rename).
+ * Previne corrupção de arquivo em caso de falha durante escrita.
+ * @param {string} filePath - Caminho absoluto do arquivo destino
+ * @param {object} obj - Objeto a ser serializado como JSON
+ */
+function writeJsonSafe(filePath, obj) {
+    const tmp = filePath + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(obj, null, 2), "utf8");
+    fs.renameSync(tmp, filePath);
+}
+
+/**
+ * Garante que um arquivo existe, criando com conteúdo padrão se necessário.
+ * Não sobrescreve arquivos existentes (idempotente).
+ * @param {string} filePath - Caminho absoluto do arquivo
+ * @param {string} content - Conteúdo padrão caso o arquivo precise ser criado
+ * @returns {boolean} true se o arquivo foi criado, false se já existia
+ */
+function ensureFile(filePath, content) {
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, content, "utf8");
+        console.log(`✔ Criado ${path.basename(filePath)}`);
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Inicializa a estrutura de configuração com seções padrão.
+ * Não sobrescreve seções que já existam no objeto config.
+ * @param {object} config - Objeto de configuração parcial
+ * @returns {object} Configuração com todas as seções garantidas
+ */
+function initConfigDefaults(config) {
+    config.gateway = config.gateway || {};
+    config.auth = config.auth || {};
+    config.channels = config.channels || {};
+    config.filesystem = config.filesystem || {};
+    config.filesystem.allowlist = config.filesystem.allowlist || [];
+    config.sandbox = config.sandbox || {};
+    return config;
+}
+
+module.exports = { readJsonSafe, writeJsonSafe, ensureFile, initConfigDefaults };

package/lib/detect.js

@@ -0,0 +1,49 @@
+/**
+ * Módulo de detecção de ambiente para o OpenClaw Setup Wizard.
+ * Identifica o tipo de sistema operacional e contexto de execução
+ * (Docker, WSL2, VPS, local) para adaptar o comportamento do wizard.
+ * 
+ * @module lib/detect
+ */
+const fs = require("fs");
+const os = require("os");
+
+/**
+ * Detecta se o processo está rodando dentro de um container Docker.
+ * Verifica dois indicadores: /.dockerenv e menção a "docker" no cgroup.
+ * @returns {boolean} true se está em Docker
+ */
+function isDocker() {
+    return fs.existsSync("/.dockerenv") ||
+        (fs.existsSync("/proc/1/cgroup") && fs.readFileSync("/proc/1/cgroup", "utf8").includes("docker"));
+}
+
+/**
+ * Detecta se o processo está rodando dentro do WSL2.
+ * Usa o release do kernel ("microsoft") e a env WSL_DISTRO_NAME.
+ * @returns {boolean} true se está em WSL2
+ */
+function isWSL() {
+    return os.platform() === "linux" &&
+        (os.release().toLowerCase().includes("microsoft") || !!process.env.WSL_DISTRO_NAME);
+}
+
+/**
+ * Detecta o ambiente de execução para adaptar o wizard.
+ * Ordem de prioridade: Docker > WSL2 > Windows > Mac > Linux VPS (root) > Linux > desconhecido.
+ * @returns {"docker"|"wsl2"|"windows"|"mac"|"linux-vps-root"|"linux"|"unknown"} Tipo de ambiente
+ */
+function detectEnvironment() {
+    if (isDocker()) return "docker";
+    if (isWSL()) return "wsl2";
+    if (os.platform() === "win32") return "windows";
+    if (os.platform() === "darwin") return "mac";
+    if (os.platform() === "linux") {
+        const user = os.userInfo().username;
+        if (user === "root") return "linux-vps-root";
+        return "linux";
+    }
+    return "unknown";
+}
+
+module.exports = { isDocker, isWSL, detectEnvironment };