@fabioforest/openclaw 3.9.0 → 3.10.0

package/bin/openclaw.js

@@ -43,7 +43,8 @@ const COMMANDS = {
 function parseArgs(argv) {
     const flags = {
         plan: true, // Default: PLAN mode (read-only)
-        audit: true // Default: Generate audit logs
+        audit: true, // Default: Generate audit logs
+        _: [] // Captura subcomandos/args
     };
     let command = null;
 
@@ -62,7 +63,6 @@ function parseArgs(argv) {
             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") {
@@ -71,13 +71,21 @@ function parseArgs(argv) {
             flags.audit = false;
         } else if (arg === "--merge") {
             flags.merge = true;
-        } else if (!arg.startsWith("-") && !command) {
-            command = arg;
+        } else if (!arg.startsWith("-")) {
+            if (!command) {
+                command = arg;
+            } else {
+                flags._.push(arg); // Captura subcomandos/args
+            }
         }
     }
 
-    // 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)
+    // Regra de precedência: apply sempre vence plan
+    if (flags.apply) flags.plan = false;
+
+    // Constrói ajudantes semânticos a partir de _
+    flags.subcommand = flags._[0] || null;
+    flags.args = flags._.slice(1);
 
     return { command, flags };
 }

package/lib/cli/ide.js

@@ -14,6 +14,7 @@ const readline = require("readline");
 const { detectContext, getAuditHeader } = require("../context");
 const { copyDirRecursive } = require("./init");
 const { writeCliAudit } = require("../utils/audit-writer");
+const { guardPlan } = require("../utils/scope_guard");
 
 // Caminho dos templates do pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
@@ -28,21 +29,9 @@ function writeAudit(targetPath, lines, flags) {
     writeCliAudit(targetPath, lines, flags, "ide");
 }
 
-/**
- * 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";
+    // Detectar sub-comando alinhado com o parseArgs global
+    const subCmd = flags.subcommand || "install";
 
     if (subCmd === "doctor") {
         return runDoctor({ targetPath, flags });
@@ -84,6 +73,16 @@ async function runInstall({ targetPath, flags }) {
         console.log("  ✅ KEEP    .agent/state/ (já existe)");
     }
 
+    // 2.5 Scope Guard
+    const intents = { writes: [agentDst, stateDir], deletes: [], overwrites: [] };
+    // Se for um force, significa que um overwrite/delete de diretório ocorrerá
+    if (fs.existsSync(agentDst) && flags.force) {
+        intents.deletes.push(agentDst);
+        intents.overwrites.push(agentDst);
+    }
+
+    await guardPlan(targetPath, intents, flags);
+
     if (planMode) {
         console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
         console.log("   Para aplicar, rode: npx openclaw ide install --apply");

package/lib/cli/init.js

@@ -14,6 +14,7 @@ const readline = require("readline");
 const { initConfigDefaults, writeJsonSafe } = require("../config");
 const { detectContext, getAuditHeader } = require("../context");
 const { writeCliAudit } = require("../utils/audit-writer");
+const { guardPlan } = require("../utils/scope_guard");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
@@ -107,6 +108,17 @@ async function run({ targetPath, flags }) {
         actions.push({ type: "NOOP", path: configPath, reason: "Config exists" });
     }
 
+    // 2.5. Acionar Scope Guard
+    const intents = { writes: [], deletes: [], overwrites: [] };
+    for (const a of actions) {
+        if (a.type === "DELETE_DIR") intents.deletes.push(a.path);
+        if (a.type === "CREATE_DIR") intents.writes.push(a.path);
+        if (a.type === "CREATE_FILE") intents.writes.push(a.path);
+        if (a.type === "COPY_DIR" || a.type === "MERGE_DIR") intents.writes.push(a.to);
+    }
+
+    await guardPlan(targetPath, intents, flags);
+
     // 3. Exibir Plano
     console.log(`\n🧭 Plano de Execução (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
     console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
@@ -122,7 +134,7 @@ async function run({ targetPath, flags }) {
 
     if (planMode) {
         console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
-        console.log("   Para aplicar, rode: npx openclaw init --apply [--merge|--force]");
+        console.log("   Para aplicar, rode o comando com --apply");
         return;
     }
 

package/lib/cli/uninstall.js

@@ -15,6 +15,7 @@ const fs = require("fs");
 const path = require("path");
 const readline = require("readline");
 const { detectContext, getAuditHeader } = require("../context");
+const { guardPlan } = require("../utils/scope_guard");
 
 function ask(q) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -103,6 +104,10 @@ async function run({ targetPath, flags }) {
         console.log(`   🔴 REMOVER  openclaw.json`);
     }
 
+    // Acionar Scope Guard para todos os deletes listados
+    const intents = { writes: [], deletes: toRemove.map(i => i.path), overwrites: [] };
+    await guardPlan(targetPath, intents, flags);
+
     // Verificar audit logs que seriam perdidos
     const auditDir = path.join(agentDir, "audit");
     if (fs.existsSync(auditDir)) {

package/lib/cli/update.js

@@ -15,6 +15,7 @@ const crypto = require("crypto");
 const readline = require("readline");
 const { detectContext, getAuditHeader } = require("../context");
 const { writeCliAudit } = require("../utils/audit-writer");
+const { guardPlan } = require("../utils/scope_guard");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
@@ -127,6 +128,12 @@ async function run({ targetPath, flags }) {
     const actions = planUpdates(TEMPLATES_DIR, agentDir);
     const audit = [getAuditHeader(ctx, "update", flags)];
 
+    // 1.5 Acionar Scope Guard
+    const intents = { writes: [], deletes: [], overwrites: [] };
+    for (const a of actions.added) intents.writes.push(a.dest);
+    for (const a of actions.updated) intents.overwrites.push(a.dest);
+    await guardPlan(targetPath, intents, flags);
+
     // 2. Exibir Plano
     console.log(`\n🧭 Plano de Atualização (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
     console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);

package/lib/utils/scope_guard.js

@@ -0,0 +1,112 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+/**
+ * Utilitário para prompt interativo.
+ */
+function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => rl.question(query, (ans) => {
+        rl.close();
+        resolve(ans.trim());
+    }));
+}
+
+/**
+ * Valida se um caminho pretendido está dentro do diretório seguro.
+ * @param {string} targetPath - Caminho do projeto destino.
+ * @param {string} fileToMutate - O arquivo/pasta a ser mexido.
+ * @returns {boolean} - True se .agent/** ou default safe.
+ */
+function isPathInSafeScope(targetPath, fileToMutate) {
+    // Escopo seguro default: pasta `.agent` na raiz do targetPath
+    const safeScope = path.join(targetPath, ".agent");
+    const absoluteMutate = path.resolve(targetPath, fileToMutate);
+
+    // Arquivos no diretório pai principal que não deveriam ser bloqueados:
+    // Padrão do projeto autoriza explicitamente "openclaw.json", ".env.example" no wizard? 
+    // Para simplificar, focamos na "prisão" primária.
+
+    // allow openclaw.json default config
+    if (absoluteMutate === path.join(targetPath, "openclaw.json")) return true;
+
+    // Retorna true se começa com o caminho the escopo.
+    return absoluteMutate.startsWith(safeScope);
+}
+
+/**
+ * Escudo de Proteção "Scope Guard"
+ * Evita que o CLI apague ou modifique arquivos da aplicação nativa (ex: index.js, package.json do usuário).
+ * 
+ * @param {string} targetPath - Caminho de execução (process.cwd geralmente)
+ * @param {object} intents - Objeto contendo listas { writes: [], deletes: [], overwrites: [] } com paths relativos ou absolutos
+ * @param {object} flags - As CLI Flags (`force`, `yes`, `apply`)
+ */
+async function guardPlan(targetPath, intents = { writes: [], deletes: [], overwrites: [] }, flags = {}) {
+    const outOfScope = {
+        writes: intents.writes.filter(p => !isPathInSafeScope(targetPath, p)),
+        deletes: intents.deletes.filter(p => !isPathInSafeScope(targetPath, p)),
+        overwrites: intents.overwrites.filter(p => !isPathInSafeScope(targetPath, p)),
+    };
+
+    const totalRisks = outOfScope.writes.length + outOfScope.deletes.length + outOfScope.overwrites.length;
+
+    // Se tudo ok (nenhuma fuga da jail), permitimos silenciosamente sem drama
+    if (totalRisks === 0) return true;
+
+    console.log("\n🛡️  [SCOPE GUARD ALERTA DE SEGURANÇA]");
+    console.log("-----------------------------------------");
+    console.log(`Detectado tentativa de alterar dados FORA do sandbox (.agent/**).`);
+
+    if (outOfScope.writes.length > 0) {
+        console.log("⚠️ Arquivos a GERAR fora do escopo:", outOfScope.writes);
+    }
+    if (outOfScope.overwrites.length > 0) {
+        console.log("🧨 Arquivos a SOBRESCREVER fora do escopo:", outOfScope.overwrites);
+    }
+    if (outOfScope.deletes.length > 0) {
+        console.log("🔥 DELETE SOLICITADO fora do escopo:", outOfScope.deletes);
+    }
+    console.log("-----------------------------------------\n");
+
+    // Lógica para modo interativo. Se flag Force vier sem ask, permitimos por conta-risco.
+    if (flags.force) {
+        console.log("⚠️ Flag --force detectada. Destravando ação destrutiva fora da sandbox.");
+        return true;
+    }
+
+    if (flags.yes) {
+        console.log("❌ Bloqueado! Não permitimos escapes da sandbox via '--yes'. Você deve rodar o processo interativamente ou usar --force.");
+        process.exit(1);
+    }
+
+    // Interactive confirmation com hard-stop (obriga escrever DESTRUCTIVE para deletes/overwrites)
+    if (outOfScope.deletes.length > 0 || outOfScope.overwrites.length > 0) {
+        const ans = await askQuestion("Perigo crítico. Para aprovar sobrescritas ou apagamentos fora do .agent, digite 'DESTRUCTIVE': ");
+        if (ans !== "DESTRUCTIVE") {
+            console.log("⏹️ Cancelado pelo Módulo Scope Guard.");
+            process.exit(1);
+        }
+        return true;
+    }
+
+    // Para WRITES brandos: conf simples
+    const ans = await askQuestion("Aprovar criação de novas rotas fora do sandbox? [y/N]: ");
+    if (ans.toLowerCase() !== "y") {
+        console.log("⏹️ Cancelado pelo Módulo Scope Guard.");
+        process.exit(1);
+    }
+
+    return true;
+}
+
+module.exports = {
+    guardPlan,
+    isPathInSafeScope
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabioforest/openclaw",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "Agentes autônomos para engenharia de software",
   "publishConfig": {
     "access": "public"