sicario-red-team 0.5.4 → 0.5.6

package/bin/sicario.js

@@ -24,6 +24,7 @@ import { Command } from 'commander';
 import { pathToFileURL, fileURLToPath } from 'url';
 import pc from 'picocolors';
 import { getApiKey, setApiKey } from '../src-cli/utils/config.js';
+import { Keymaster } from '../src-cli/services/keymaster.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const clack = require('@clack/prompts');
@@ -68,6 +69,7 @@ program
   .option('--swarm', 'Deploy multiple specialized nodes in parallel')
   .option('--tier <level>', 'Sicario Tier (SHADOW|OPERATOR|CARTEL)', 'SHADOW')
   .option('--auth <string>', 'Session token or cookie string for authenticated scans')
+  .option('--intent <string>', 'Focus swarm on a specific red-team intent (e.g. "bypass billing")')
   .action(async (posTarget, options) => {
     try {
       const finalTarget = posTarget || options.target; // Support both styles
@@ -103,6 +105,13 @@ program
       }
 
       console.log(`\x1b[1m\x1b[32m[+] DEPLOYING SICARIO RED-TEAM SWARM v${pkg.version}\x1b[0m`);
+      
+      // Auto-Vault Detection
+      if (!options.auth && Keymaster.hasVault()) {
+        console.log(`\x1b[36m[*] Keymaster: Vaulted session detected. Injecting into swarm...\x1b[0m`);
+        options.vault = Keymaster.getVaultPath();
+      }
+
       // Premium Boot Sequence
       await bootSwarm();
 
@@ -122,11 +131,19 @@ program
   .description('Launch a Sustained Siege (Continuous Monitoring)')
   .argument('[target]', 'Target URL')
   .option('-t, --target <url>', 'Target URL')
+  .option('--intent <string>', 'Specific red-team intent for the siege')
   .action(async (posTarget, options) => {
     try {
       options.target = posTarget || options.target;
       
       console.log(`\x1b[1m\x1b[32m[+] INITIATING SUSTAINED SICARIO SIEGE v${pkg.version}\x1b[0m`);
+      
+      // Auto-Vault Detection
+      if (!options.auth && Keymaster.hasVault()) {
+        console.log(`\x1b[36m[*] Keymaster: Vaulted session detected. Injecting into siege overwatch...\x1b[0m`);
+        options.vault = Keymaster.getVaultPath();
+      }
+
       // Premium Boot Sequence
       await bootSwarm();
 
@@ -139,6 +156,54 @@ program
     }
   });
 
+program
+  .command('auth')
+  .description('Human-in-the-loop session extraction (The Keymaster)')
+  .argument('[target]', 'Target login URL')
+  .action(async (target) => {
+    const keymaster = new Keymaster();
+    const finalTarget = target || await clack.text({ 
+      message: 'Establish breach point (Login URL)',
+      placeholder: 'https://example.com/login'
+    });
+    
+    if (clack.isCancel(finalTarget)) {
+      clack.cancel('Operation aborted.');
+      process.exit(0);
+    }
+    
+    await keymaster.captureSession(finalTarget);
+  });
+
+const watchCommandPath = pathToFileURL(path.join(__dirname, '../src-cli/commands/watch.js')).href;
+
+program
+  .command('watch')
+  .description('Continuous Localhost Siege (Lazy Watcher)')
+  .argument('[target]', 'Target URL')
+  .option('-t, --target <url>', 'Target URL')
+  .action(async (posTarget, options) => {
+    try {
+      options.target = posTarget || options.target;
+      
+      console.log(`\x1b[1m\x1b[32m[+] ACTIVATING LAZY WATCHER v${pkg.version}\x1b[0m`);
+      
+      if (!options.auth && Keymaster.hasVault()) {
+        console.log(`\x1b[36m[*] Keymaster: Vaulted session detected. Injecting into watcher...\x1b[0m`);
+        options.vault = Keymaster.getVaultPath();
+      }
+
+      await bootSwarm();
+
+      const { watchCommand } = await import(watchCommandPath);
+      await watchCommand(options.target, options);
+    } catch (err) {
+      console.error('Fatal: Failed to load watcher command logic.');
+      console.error(err);
+      process.exit(1);
+    }
+  });
+
 try {
   program.parse(process.argv);
 } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sicario-red-team",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "type": "module",
   "description": "Autonomous Agentic Red-Teaming Swarm Protocol",
   "repository": {

package/src-cli/commands/hit.js

@@ -8,6 +8,8 @@ import { ConvexClient } from 'convex/browser';
 import { runScout } from '../nodes/scout.js';
 import { runBreacher } from '../nodes/breacher.js';
 import { CriticNode } from '../nodes/critic.js';
+import { runScribe } from '../nodes/scribe.js';
+import { translateIntent } from '../utils/llm.js';
 import { theme } from '../utils/theme.js';
 
 // Initialize Convex Client (will use CONVEX_URL from .env)
@@ -37,6 +39,14 @@ export async function hitCommand(target, options) {
     const CURRENT_TIER = (options.tier || 'SHADOW').toUpperCase();
     log.info(pc.magenta(`◈  LICENSE TIER: ${pc.bold(CURRENT_TIER)}`));
 
+    // 1. Intent Translation (The Swarm Strategist Node)
+    let intentVectors = null;
+    if (options.intent) {
+        log.step(`[System] : Translating intent into specialized attack vectors...`);
+        intentVectors = await translateIntent(options.intent);
+        log.info(pc.magenta(`◈  INTENT VECTORS: ${intentVectors.join(', ')}`));
+    }
+
     // 2. Bounded Autonomy Manifest (The 2026 Trust Layer)
     console.log(pc.dim('\n┌  AGENT PERMISSIONS MANIFEST ─── (READ-ONLY) ──────╮'));
     console.log(pc.dim('│  ✓ DOM Observation : AUTHORIZED                  │'));
@@ -143,6 +153,13 @@ export async function hitCommand(target, options) {
                                  clean.thoughtProcess.includes("Architect") ? "THE ARCHITECT" : 
                                  clean.thoughtProcess.includes("Ghost") ? "THE GHOST NODE" : "GENERAL BREACHER";
 
+                // 6.1 [Scribe] Remediation Generation (Strictly gated by Critic results)
+                let scribePatch = null;
+                if (isReal) {
+                    log.step(`[Scribe] : Automating remedial code patch...`);
+                    scribePatch = await runScribe(breachReport, audit);
+                }
+
                 console.log('\n' + pc.bold(pc.red(` ⚠ EXPLOIT SUCCESSFUL [${clean.title}]`)));
                 console.log(pc.cyan(` ◇  AGENT IDENTIFIED: ${nodeName}`));
                 console.log(pc.red(` Vector: ${clean.vector}`));
@@ -191,6 +208,13 @@ export async function hitCommand(target, options) {
                         console.log(pc.white(drawBoxRow(`Visit sicario-red-team.com to unlock the patch.`, boxWidth)));
                     }
                     
+                    if (scribePatch) {
+                        console.log(pc.green(`├${'─'.repeat(boxWidth - 2)}┤`));
+                        console.log(pc.green(`│ ${pc.bold('SCRIBE REMEDIATION PATCH (CURSOR-READY)').padEnd(boxWidth - 4)} │`));
+                        const scribeLines = wrap(scribePatch, boxWidth - 4);
+                        scribeLines.forEach(line => console.log(pc.green(drawBoxRow(line, boxWidth))));
+                    }
+
                     console.log(pc.cyan(`├${'─'.repeat(boxWidth - 2)}╯`) + '\n');
                 }
             }

package/src-cli/commands/watch.js

@@ -0,0 +1,57 @@
+import { hitCommand } from './hit.js';
+import { runScout } from '../nodes/scout.js';
+import clack from '@clack/prompts';
+const { log } = clack;
+import pc from 'picocolors';
+
+/**
+ * Lazy Watcher: Performs continuous monitoring with heavy debouncing and DOM diffing.
+ * Goal: Zero API calls if no structural changes are detected.
+ */
+export async function watchCommand(target, options) {
+    let lastElementsHash = null;
+    let debounceTime = 15000; // 15 seconds as requested
+
+    log.step(pc.cyan(`[Watcher] : Initiating Lazy Watcher for ${target}...`));
+    log.info(pc.dim(`Status: Monitoring structure. Min cooldown: 15s. API calls only on change.`));
+
+    // Initial run
+    try {
+        await hitCommand(target, options);
+    } catch (e) {}
+
+    while (true) {
+        try {
+            // 1. Silent Recon (Scout node - browser based, but local cost)
+            const elements = await runScout(target, options);
+            
+            // Generate a structural hash (tags, types, and names)
+            const structuralElements = elements.map(e => ({ 
+                tag: e.tag, 
+                id: e.id, 
+                name: e.name, 
+                type: e.type 
+            }));
+            const currentHash = JSON.stringify(structuralElements);
+
+            if (currentHash !== lastElementsHash) {
+                if (lastElementsHash !== null) {
+                    log.step(pc.yellow(`\n[Watcher] : Structural change detected. Initializing mini-siege...`));
+                    // Trigger the hit
+                    await hitCommand(target, options);
+                }
+                lastElementsHash = currentHash;
+            } else {
+                // No change, just log a heartbeat in debug mode if needed
+                process.stdout.write(pc.dim('.'));
+            }
+
+            // Wait for 15s before next check
+            await new Promise(r => setTimeout(r, debounceTime));
+
+        } catch (err) {
+            log.error(`[Watcher] : Connection error. Retrying...`);
+            await new Promise(r => setTimeout(r, 5000));
+        }
+    }
+}

package/src-cli/nodes/scout.js

@@ -11,7 +11,14 @@ import path from 'path';
  */
 export async function runScout(url, options = {}) {
     const browser = await chromium.launch({ headless: true });
-    const context = await browser.newContext();
+    
+    // 0. Keymaster Session Injection (storageState)
+    const contextOptions = {};
+    if (options.vault && fs.existsSync(options.vault)) {
+        contextOptions.storageState = options.vault;
+    }
+    
+    const context = await browser.newContext(contextOptions);
 
     // 0. Session Injection (The Authentication Engine)
     if (options.auth) {

package/src-cli/nodes/scribe.js

@@ -0,0 +1,42 @@
+import Cerebras from '@cerebras/cerebras_cloud_sdk';
+import 'dotenv/config';
+
+/**
+ * The Scribe Node: Generates "Cursor-ready" patches and remediation prompts.
+ * Strictly gated by the Critic node to stay within Cerebras Free Tier limits.
+ */
+export async function runScribe(breachReport, audit) {
+    const client = new Cerebras({
+        apiKey: process.env.CEREBRAS_API_KEY,
+    });
+
+    const systemPrompt = `
+You are 'The Scribe' node of the Sicario Red-Teaming Swarm. 
+Your goal is to provide a "Cursor-ready" remediation prompt that a developer can paste into their AI code editor to fix a confirmed vulnerability.
+
+VULNERABILITY: ${breachReport.title}
+VECTOR: ${breachReport.vector}
+CRITIC JUSTIFICATION: ${audit.reasoning}
+
+INSTRUCTIONS:
+1. Provide a concise, clinical description of the fix.
+2. Provide a "Cursor Prompt" (a prompt for another AI to use) enclosed in triple backticks.
+3. Keep it brief to save on outbound tokens.
+`;
+
+    try {
+        const completion = await client.chat.completions.create({
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: 'Generate remediation prompt.' }
+            ],
+            model: 'llama3.1-8b', // Using the faster, cheaper 8B model as requested
+            temperature: 0.1,
+            max_tokens: 300
+        });
+
+        return completion.choices[0].message.content;
+    } catch (error) {
+        return "Scribe node offline: Mitigation deferred to manual review.";
+    }
+}

package/src-cli/services/keymaster.js

@@ -0,0 +1,70 @@
+import { chromium } from 'playwright';
+import fs from 'fs';
+import readline from 'readline';
+import path from 'path';
+import pc from 'picocolors';
+
+const VAULT_FILE = path.join(process.cwd(), '.sicario-vault.json');
+
+/**
+ * Keymaster Service: Handles session state extraction and vaulting.
+ * Supports Human-in-the-loop (HITL) authentication for enterprise targets.
+ */
+export class Keymaster {
+  constructor() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+  }
+
+  /**
+   * Phase 1: Human-in-the-loop Session Capture.
+   * Opens a visible browser for the user to authenticate manually.
+   */
+  async captureSession(targetUrl) {
+    console.log(`\n${pc.cyan('[?] Keymaster initiating manual breach on:')} ${pc.bold(targetUrl)}`);
+    console.log(`   ${pc.yellow('[!] Action Required: A browser will open. Log in, pass MFA, and navigate to the dashboard.')}`);
+
+    try {
+      // Launch visible browser for the human operator
+      const browser = await chromium.launch({ headless: false });
+      const context = await browser.newContext();
+      const page = await context.newPage();
+
+      await page.goto(targetUrl);
+
+      // Wait for the operator to signal the breach is complete
+      await new Promise((resolve) => {
+        this.rl.question(`\n${pc.green('[+] Press [ENTER] here when you are fully logged in and ready for state extraction...')}`, resolve);
+      });
+
+      // Extract the state (Cookies, LocalStorage, etc.)
+      await context.storageState({ path: VAULT_FILE });
+      
+      await browser.close();
+      this.rl.close();
+
+      console.log(`\n${pc.green('[✔] Session Extracted and Vaulted successfully.')}`);
+      console.log(`   ${pc.red('[!] CRITICAL: Ensure .sicario-vault.json is in your .gitignore')}\n`);
+    } catch (err) {
+      console.error(pc.red(`\n[X] Keymaster capture failed: ${err.message}`));
+      this.rl.close();
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Returns the absolute path to the session vault.
+   */
+  static getVaultPath() {
+    return VAULT_FILE;
+  }
+
+  /**
+   * Checks if a vaulted session exists.
+   */
+  static hasVault() {
+    return fs.existsSync(VAULT_FILE);
+  }
+}

package/src-cli/utils/llm.js

@@ -0,0 +1,38 @@
+import Cerebras from '@cerebras/cerebras_cloud_sdk';
+import 'dotenv/config';
+
+/**
+ * Translates a high-level security intent into specific, actionable attack vectors.
+ * Costs exactly 1 API call per siege to Llama 8B.
+ */
+export async function translateIntent(intent) {
+    const client = new Cerebras({
+        apiKey: process.env.CEREBRAS_API_KEY,
+    });
+
+    const systemPrompt = `
+You are the "Swarm Strategist" for the Sicario Red-Teaming protocol. 
+The operator provided a target intent: "${intent}".
+
+Your task: Translate this intent into 5 specific, technical attack vectors that node-based agents (Accountant, Admin, Chaos Monkey, Architect, Ghost) should look for in a DOM structure.
+
+REPLY ONLY WITH A COMMA-SEPARATED LIST OF 5 BRIEF TECHNICAL VECTORS.
+    `;
+
+    try {
+        const completion = await client.chat.completions.create({
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: 'Generate tactical vectors.' }
+            ],
+            model: 'llama3.1-8b',
+            temperature: 0.1,
+            max_tokens: 100
+        });
+
+        const rawResult = completion.choices[0].message.content.trim();
+        return rawResult.split(',').map(s => s.trim());
+    } catch (error) {
+        return ["Session State Bypass", "Hidden Field Manipulation", "Horizontal Privilege Escalation", "Input Sanitization Bypass", "Logic State Machine Exploitation"];
+    }
+}