@fabioforest/openclaw 3.0.0 → 3.4.0

package/bin/openclaw.js

@@ -28,6 +28,9 @@ const COMMANDS = {
     doctor: "../lib/cli/doctor",
     debug: "../lib/cli/debug",
     check: "../lib/cli/orchestrate",
+    inspect: "../lib/cli/inspect",
+    assist: "../lib/cli/assist",
+    ide: "../lib/cli/ide",
 };
 
 /**
@@ -36,7 +39,10 @@ const COMMANDS = {
  * @returns {{ command: string|null, flags: object }}
  */
 function parseArgs(argv) {
-    const flags = {};
+    const flags = {
+        plan: true, // Default: PLAN mode (read-only)
+        audit: true // Default: Generate audit logs
+    };
     let command = null;
 
     for (let i = 0; i < argv.length; i++) {
@@ -49,15 +55,28 @@ function parseArgs(argv) {
         } 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 === "--apply") {
+            flags.apply = true;
+            flags.plan = false; // Apply overrides Plan default
+        } else if (arg === "--plan") {
+            flags.plan = true;
+        } else if (arg === "--yes" || arg === "-y") {
+            flags.yes = true;
+        } else if (arg === "--no-audit") {
+            flags.audit = false;
+        } else if (arg === "--merge") {
+            flags.merge = true;
         } else if (!arg.startsWith("-") && !command) {
             command = arg;
         }
     }
 
+    // Se apply foi passado, plan é false (a menos que forçado explicitamente, mas apply vence na lógica acima)
+    // Se o usuário não passar nada, plan=true (default)
+
     return { command, flags };
 }
 
@@ -78,19 +97,29 @@ function showHelp() {
     setup     Roda wizard interativo de configuração
     debug     Diagnóstico avançado de instalação e rede
     check     Orquestrador inteligente (instala ou repara)
+    inspect   Analisa ambiente e contexto (100% read-only)
+    assist    Assistente geral com roteamento de skills
+    ide       Instala AI OS na IDE (ide install / ide doctor)
 
-  Opções:
+  Opções Globais:
     --path, -p <dir>   Diretório alvo (padrão: ./)
-    --force, -f        Sobrescreve .agent/ existente (init)
+    --plan             Modo Simulação (PADRÃO): Mostra o que será feito sem alterar nada
+    --apply            Modo Execução: Aplica as alterações propostas
+    --yes, -y          Confirma automaticamente (skip prompts)
+    --force, -f        Permite operações destrutivas (exige confirmação forte)
+    --no-audit         Desabilita geração de logs de auditoria
+    --merge            Atualização segura (não sobrescreve customizações)
     --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
+    npx openclaw init --plan           (Simula instalação)
+    npx openclaw init --apply          (Instala de fato)
+    npx openclaw check                 (Orquestrador seguro)
+    npx openclaw inspect               (Analisa contexto)
+    npx openclaw assist                (Assistente geral)
+    npx openclaw ide install --apply   (Instala AI OS na IDE)
 `);
 }
 

package/lib/cli/assist.js

@@ -0,0 +1,84 @@
+"use strict";
+
+/**
+ * Comando CLI: assist
+ *
+ * Assistente geral do OpenClaw AI OS.
+ * Detecta contexto, roteia para a skill correta e apresenta plano.
+ * Funciona tanto via terminal quanto como "cérebro" para IDEs (chat-first).
+ */
+
+const path = require("path");
+const readline = require("readline");
+const collectContext = require("../context/collector");
+const { matchSkill } = require("../router/match");
+
+// Caminho dos templates e skills do pacote
+const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
+const SKILLS_DIR = path.join(TEMPLATES_DIR, ".agent", "skills");
+
+function ask(q) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((res) => rl.question(q, (ans) => { rl.close(); res(ans.trim()); }));
+}
+
+/**
+ * Executa o comando assist (menu interativo com roteamento de skills).
+ * @param {object} options
+ * @param {string} options.targetPath — diretório alvo
+ * @param {object} options.flags — flags do CLI
+ */
+async function run({ targetPath, flags }) {
+    // 1. Coletar contexto (read-only)
+    const ctx = collectContext({
+        targetPath,
+        templatesDir: TEMPLATES_DIR,
+    });
+
+    console.log("\n🧠 OpenClaw Assist — Modo PLAN por padrão (seguro)\n");
+    console.log(`   IDE: ${ctx.ide} | OpenClaw: ${ctx.openclaw.hasAgentDir ? "instalado" : "não instalado"}`);
+    console.log(`   Plataforma: ${ctx.env.platform} | Docker: ${ctx.env.docker}\n`);
+
+    // 2. Se não tem OpenClaw instalado, sugerir instalação
+    if (!ctx.openclaw.hasAgentDir) {
+        console.log("⚠️  OpenClaw não detectado neste workspace.");
+        console.log("   Rode: npx openclaw init --apply  (para instalar)\n");
+        return;
+    }
+
+    // 3. Pedir solicitação do usuário
+    console.log("Descreva o que deseja fazer:");
+    console.log("  (ex: 'criar skill', 'melhorar segurança', 'mission control tick')\n");
+    const request = await ask("> ");
+
+    if (!request) {
+        console.log("⏹️  Nenhuma solicitação. Saindo.");
+        return;
+    }
+
+    // 4. Rotear para skill correta
+    const match = matchSkill({ skillsDir: SKILLS_DIR, userText: request });
+
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    if (match.chosen) {
+        console.log(`🎯 Skill selecionada: ${match.chosen.name}`);
+        console.log(`   Descrição: ${match.chosen.description}`);
+    } else {
+        console.log("❓ Nenhuma skill correspondente encontrada.");
+        console.log("   Tente reformular a solicitação ou use 'openclaw inspect' para ver skills disponíveis.");
+    }
+
+    if (match.alternatives.length > 0) {
+        console.log(`\n   Alternativas:`);
+        match.alternatives.forEach(a => console.log(`      • ${a.name}: ${a.description}`));
+    }
+
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("\n✅ Protocolo recomendado:");
+    console.log("   1) Rodar INSPECT (read-only) e revisar o contexto");
+    console.log("   2) Descrever exatamente o que quer alterar");
+    console.log("   3) Confirmar APPLY para executar");
+    console.log("   4) Tudo será registrado em .agent/audit/\n");
+}
+
+module.exports = { run };

package/lib/cli/doctor.js

@@ -166,12 +166,16 @@ 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: "ok",
+                message: "✅ Control UI acessível em http://127.0.0.1:18789"
+            };
         }
         return {
             name: "porta 18789",
             status: "warn",
-            message: "Porta livre — serviço OpenClaw pode estar parado",
+            message: "Porta livre — serviço OpenClaw pode estar parado (UI indisponível)",
         };
     } catch {
         return {
@@ -182,6 +186,30 @@ async function checkPort() {
     }
 }
 
+/**
+ * Verifica interfaces de rede para detectar VPN WireGuard ativa (Linux only).
+ * @returns {CheckResult}
+ */
+function checkVpnInterface() {
+    const osType = require("os").type();
+    if (osType !== "Linux") {
+        return { name: "vpn interface", status: "ok", message: "N/A (não é Linux)" };
+    }
+
+    try {
+        const interfaces = require("os").networkInterfaces();
+        const wgInterface = Object.keys(interfaces).find(iface => iface.startsWith("wg"));
+
+        if (wgInterface) {
+            return { name: "vpn interface", status: "ok", message: `Detectada: ${wgInterface}` };
+        } else {
+            return { name: "vpn interface", status: "warn", message: "Nenhuma interface wg* encontrada" };
+        }
+    } catch (e) {
+        return { name: "vpn interface", status: "warn", message: "Erro ao listar interfaces" };
+    }
+}
+
 /**
  * Verifica ambiente detectado.
  * @returns {CheckResult}
@@ -252,6 +280,12 @@ async function run({ targetPath, flags }) {
     // 4. .agent/
     results.push(...checkAgentDir(agentDir));
 
+    // 5. VPN (se Linux)
+    const vpnCheck = checkVpnInterface();
+    if (vpnCheck.message !== "N/A (não é Linux)") {
+        results.push(vpnCheck);
+    }
+
     // Exibir relatório
     printReport(results);
     console.log("");
@@ -263,4 +297,4 @@ async function run({ targetPath, flags }) {
     }
 }
 
-module.exports = { run, checkConfig, checkAgentDir, checkPort, checkEnvironment };
+module.exports = { run, checkConfig, checkAgentDir, checkPort, checkEnvironment, checkVpnInterface };

package/lib/cli/ide.js

@@ -0,0 +1,218 @@
+"use strict";
+
+/**
+ * Comando CLI: ide
+ *
+ * Gerencia a instalação do OpenClaw AI OS em IDEs.
+ * Sub-comandos: install (plan/apply), doctor.
+ * Sempre segue o protocolo consent-first.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { detectContext, getAuditHeader } = require("../context");
+const { copyDirRecursive } = require("./init");
+
+// Caminho dos templates do pacote
+const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
+
+function ask(q) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((res) => rl.question(q, (ans) => { rl.close(); res(ans.trim()); }));
+}
+
+/**
+ * Grava log de auditoria para o comando ide.
+ */
+function writeAudit(targetPath, lines, flags) {
+    if (flags.audit === false) return;
+    const auditDir = path.join(targetPath, ".agent", "audit");
+    if (!fs.existsSync(auditDir)) {
+        try { fs.mkdirSync(auditDir, { recursive: true }); } catch (e) { }
+    }
+    const filename = `ide-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
+    try {
+        fs.writeFileSync(path.join(auditDir, filename), lines.join("\n") + "\n", "utf8");
+    } catch (e) {
+        console.error("⚠️  Falha ao gravar auditoria:", e.message);
+    }
+}
+
+/**
+ * Executa o comando ide.
+ * Uso: openclaw ide install [--apply] [--force]
+ *      openclaw ide doctor
+ *
+ * @param {object} options
+ * @param {string} options.targetPath — diretório alvo
+ * @param {object} options.flags — flags do CLI
+ */
+async function run({ targetPath, flags }) {
+    // Detectar sub-comando a partir de args restantes
+    // O bin/openclaw.js passa o comando "ide", então precisamos
+    // verificar os args para o sub-comando
+    const args = process.argv.slice(3);
+    const subCmd = args.find(a => !a.startsWith("-")) || "install";
+
+    if (subCmd === "doctor") {
+        return runDoctor({ targetPath, flags });
+    }
+
+    return runInstall({ targetPath, flags });
+}
+
+/**
+ * Sub-comando: ide install
+ * Instala .agent/ no projeto para uso em IDEs (plan/apply).
+ */
+async function runInstall({ targetPath, flags }) {
+    const agentDst = path.join(targetPath, ".agent");
+    const agentSrc = path.join(TEMPLATES_DIR, ".agent");
+    const ctx = detectContext(targetPath);
+    const planMode = !flags.apply;
+    const audit = [getAuditHeader(ctx, "ide install", flags)];
+
+    console.log(`\n🧭 IDE Install — Plano (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
+    console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
+
+    if (fs.existsSync(agentDst) && !flags.force) {
+        console.log("  ✅ KEEP    .agent/ (já existe)");
+        console.log("  📦 MERGE   Novos templates serão adicionados (preservando existentes)");
+    } else if (fs.existsSync(agentDst) && flags.force) {
+        console.log("  🔥 DELETE  .agent/ (--force)");
+        console.log("  📦 COPY    templates/.agent -> .agent/");
+    } else {
+        console.log("  📁 CREATE  .agent/");
+        console.log("  📦 COPY    templates/.agent -> .agent/");
+    }
+
+    // State templates (mission_control.json, MEMORY.md)
+    const stateDir = path.join(agentDst, "state");
+    if (!fs.existsSync(stateDir)) {
+        console.log("  📁 CREATE  .agent/state/ (Mission Control + MEMORY)");
+    } else {
+        console.log("  ✅ KEEP    .agent/state/ (já existe)");
+    }
+
+    if (planMode) {
+        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
+        console.log("   Para aplicar, rode: npx openclaw ide install --apply");
+        return;
+    }
+
+    // Confirmação
+    if (!flags.yes) {
+        if (flags.force && fs.existsSync(agentDst)) {
+            const phrase = await ask("⚠️  Digite 'DELETE .agent' para confirmar: ");
+            if (phrase !== "DELETE .agent") {
+                console.log("⏹️  Cancelado.");
+                return;
+            }
+        } else {
+            const ok = await ask("\nAplicar instalação IDE? (y/N): ");
+            if (ok.toLowerCase() !== "y") {
+                console.log("⏹️  Cancelado.");
+                return;
+            }
+        }
+    }
+
+    // Execução
+    try {
+        console.log("\n🚀 Executando...");
+
+        if (fs.existsSync(agentDst) && flags.force) {
+            fs.rmSync(agentDst, { recursive: true, force: true });
+            audit.push("- ACT: DELETED .agent/");
+        }
+
+        const isMerge = fs.existsSync(agentDst);
+        const stats = copyDirRecursive(agentSrc, agentDst, undefined, isMerge);
+        audit.push(`- ACT: ${isMerge ? "MERGED" : "COPIED"} templates (Files: ${stats.files}, Skipped: ${stats.skipped})`);
+
+        // Criar state se necessário
+        const stateTarget = path.join(agentDst, "state");
+        if (!fs.existsSync(stateTarget)) {
+            fs.mkdirSync(stateTarget, { recursive: true });
+            // Criar mission_control.json default
+            const mcDefault = {
+                project_status: "active",
+                project_name: path.basename(targetPath),
+                sprint_goal: "",
+                agents: [
+                    { id: "orchestrator", role: "orchestrator", active: true },
+                    { id: "researcher", role: "researcher", active: true },
+                    { id: "writer", role: "writer", active: true },
+                ],
+                task_queue: [],
+                history: [],
+                settings: {
+                    work_dir: "mission_control",
+                    max_tasks_per_tick: 2,
+                    default_priority: "medium",
+                },
+            };
+            fs.writeFileSync(path.join(stateTarget, "mission_control.json"), JSON.stringify(mcDefault, null, 2));
+            fs.writeFileSync(path.join(stateTarget, "MEMORY.md"), "# Memória Persistente\n\n(Adicione aqui resumos e decisões importantes)\n");
+            audit.push("- ACT: CREATED .agent/state/ (mission_control.json + MEMORY.md)");
+        }
+
+        console.log("\n✨ IDE install concluído com sucesso!");
+        writeAudit(targetPath, audit, flags);
+
+    } catch (err) {
+        console.error(`\n❌ Falha: ${err.message}`);
+        audit.push(`\n## ERROR: ${err.message}`);
+        writeAudit(targetPath, audit, flags);
+        process.exit(1);
+    }
+}
+
+/**
+ * Sub-comando: ide doctor
+ * Verifica se a IDE está "armada" com regras, hooks e skills.
+ */
+async function runDoctor({ targetPath }) {
+    const agentDir = path.join(targetPath, ".agent");
+    const checks = [];
+
+    console.log("\n🏥 IDE Doctor — Verificando instalação para IDE:\n");
+
+    // Verificar .agent/
+    checks.push({ name: ".agent/", ok: fs.existsSync(agentDir) });
+
+    // Verificar rules
+    const rulesDir = path.join(agentDir, "rules");
+    const requiredRules = ["CONSENT_FIRST.md", "ROUTER_PROTOCOL.md"];
+    for (const rule of requiredRules) {
+        checks.push({ name: `rules/${rule}`, ok: fs.existsSync(path.join(rulesDir, rule)) });
+    }
+
+    // Verificar skills críticas
+    const skillsDir = path.join(agentDir, "skills");
+    const criticalSkills = ["openclaw-router", "openclaw-inspect", "openclaw-dev"];
+    for (const skill of criticalSkills) {
+        checks.push({ name: `skills/${skill}/SKILL.md`, ok: fs.existsSync(path.join(skillsDir, skill, "SKILL.md")) });
+    }
+
+    // Verificar hooks
+    const hooksDir = path.join(agentDir, "hooks");
+    checks.push({ name: "hooks/pre-tool-use.js", ok: fs.existsSync(path.join(hooksDir, "pre-tool-use.js")) });
+
+    // Exibir resultado
+    let allOk = true;
+    for (const c of checks) {
+        const icon = c.ok ? "✅" : "❌";
+        console.log(`   ${icon} ${c.name}`);
+        if (!c.ok) allOk = false;
+    }
+
+    if (allOk) {
+        console.log("\n🎉 IDE está totalmente configurada!");
+    } else {
+        console.log("\n⚠️  Componentes ausentes. Rode: npx openclaw ide install --apply");
+    }
+}
+
+module.exports = { run };