pentesting 0.7.5 → 0.7.7

package/dist/index.js

@@ -4249,6 +4249,9 @@ var AutonomousHackingAgent = class extends EventEmitter4 {
     output: 0,
     total: 0
   };
+  // Execution control flags
+  isPaused = false;
+  isAborted = false;
   // Rabbit hole detection settings
   STUCK_THRESHOLD = 5;
   // Same action repeat count
@@ -4450,6 +4453,13 @@ ${prompt}`
     this.think(THOUGHT_TYPE.OBSERVATION, `Target Setting: ${target}`);
     this.emit(AGENT_EVENT.TARGET_SET, target);
   }
+  // ===== Execution Control =====
+  /**
+   * Check if execution should stop (called by main loop)
+   */
+  shouldStop() {
+    return this.isPaused || this.isAborted;
+  }
   /**
    * Add a target to the discovered list (multi-target support)
    */
@@ -4491,6 +4501,20 @@ ${prompt}`
     }
     return targets;
   }
+  /**
+   * Clear all targets
+   */
+  clearTargets() {
+    this.state.target.primary = "";
+    this.state.target.discovered = [];
+    this.emit(AGENT_EVENT.TARGET_SET, { action: "cleared" });
+  }
+  /**
+   * Get target count
+   */
+  getTargetCount() {
+    return this.getAllTargets().length;
+  }
   // ===== Phase Management =====
   getCurrentPhase() {
     return this.state.phases.find((p) => p.id === this.state.currentPhase);
@@ -4577,6 +4601,9 @@ ${prompt}`
    * Uses string comparison to avoid TypeScript narrowing issues with const enums
    */
   shouldStopLoop() {
+    if (this.isPaused || this.isAborted) {
+      return true;
+    }
     const status = this.state.status;
     return status === AGENT_STATUS.PAUSED || status === AGENT_STATUS.COMPLETED || status === AGENT_STATUS.IDLE;
   }
@@ -4846,6 +4873,10 @@ Use report_finding tool for important discoveries.
           this.think(THOUGHT_TYPE.STUCK, `Tool blocked by hook: ${hookCheck.output}`);
           continue;
         }
+        if (this.shouldStopLoop()) {
+          this.think(THOUGHT_TYPE.OBSERVATION, "Execution paused before tool execution");
+          break;
+        }
         if (this.approvalManager.requiresApproval(toolName, toolInput)) {
           const risk = assessRisk(toolName, toolInput);
           this.emit(AGENT_EVENT.APPROVAL_NEEDED, {
@@ -5197,19 +5228,30 @@ Available tools: ${this.tools.map((t) => t.name).join(", ")}
 
 Respond helpfully to the user's message. If they ask to perform security testing actions, use the appropriate tools. Always explain what you're doing and why.`;
   }
-  // ===== Pause/Resume =====
+  // ===== Pause/Resume/Abort =====
   pause() {
+    this.isPaused = true;
     this.state.status = AGENT_STATUS.PAUSED;
     this.emit(AGENT_EVENT.PAUSED);
   }
   resume() {
+    this.isPaused = false;
+    this.isAborted = false;
     if (this.state.status === AGENT_STATUS.PAUSED) {
       this.state.status = AGENT_STATUS.RUNNING;
       this.emit(AGENT_EVENT.RESUMED);
     }
   }
+  abort() {
+    this.isPaused = true;
+    this.isAborted = true;
+    this.state.status = AGENT_STATUS.IDLE;
+    this.emit(AGENT_EVENT.PAUSED);
+  }
   // ===== Reset =====
   reset() {
+    this.isPaused = false;
+    this.isAborted = false;
     this.state = this.createInitialState();
     this.emit(AGENT_EVENT.RESET);
   }
@@ -6637,10 +6679,15 @@ var App = ({ autoApprove = false, target }) => {
     agent.on(AGENT_EVENT.FINDING, (finding) => {
       addMessage(MESSAGE_TYPE.SYSTEM, `\u{1F3AF} [${finding.severity.toUpperCase()}] ${finding.title}`);
       wireLoggerRef.current?.statusUpdate({ event: "finding", ...finding });
+      forceUpdate((n) => n + 1);
     });
     agent.on(AGENT_EVENT.PHASE_CHANGE, (data) => {
       addMessage(MESSAGE_TYPE.SYSTEM, `\u{1F4CD} Phase: ${data.phaseId}`);
       wireLoggerRef.current?.statusUpdate({ event: "phase_change", phase: data.phaseId });
+      forceUpdate((n) => n + 1);
+    });
+    agent.on(AGENT_EVENT.CREDENTIAL, () => {
+      forceUpdate((n) => n + 1);
     });
     agent.on(AGENT_EVENT.CONTEXT_COMPACTED, () => {
       addMessage(MESSAGE_TYPE.SYSTEM, "\u{1F4BE} Context compacted to save tokens");
@@ -6728,9 +6775,12 @@ var App = ({ autoApprove = false, target }) => {
           addMessage(
             MESSAGE_TYPE.SYSTEM,
             `\u2500\u2500 Core \u2500\u2500
-/target [domain|ip]  Set/show targets
-  add <t>  list  rm <t>  set <t>
-/start [goal]    Start autonomous pentest  
+/target [domain|ip]  Set primary target
+  add <t>   Add to list    rm <t>    Remove
+  list      Show all       set <t>   Set primary
+  clear     Remove all targets
+/start [goal]    Pentest primary target
+/start all       Attack ALL targets  
 /stop            Stop operation
 /status          Show status report
 
@@ -6828,10 +6878,17 @@ ${list}`);
               if (args[1]) {
                 agent.setTarget(args[1]);
                 addMessage(MESSAGE_TYPE.SYSTEM, `\u2605 Primary target \u2192 ${args[1]}`);
+                forceUpdate((n) => n + 1);
               } else {
                 addMessage(MESSAGE_TYPE.ERROR, "Usage: /target set <domain|ip>");
               }
               break;
+            case "clear":
+            case "reset":
+              agent.clearTargets();
+              addMessage(MESSAGE_TYPE.SYSTEM, "\u2713 All targets cleared");
+              forceUpdate((n) => n + 1);
+              break;
             default:
               agent.setTarget(subCmd);
               addMessage(MESSAGE_TYPE.SYSTEM, `\u{1F3AF} Target \u2192 ${subCmd}`);
@@ -6839,6 +6896,41 @@ ${list}`);
           return;
         case CLI_COMMAND.START:
         case "s":
+          if (args[0]?.toLowerCase() === "all") {
+            const allTargets = agent.getAllTargets();
+            if (allTargets.length === 0) {
+              addMessage(MESSAGE_TYPE.ERROR, "No targets registered. Use /target add <domain|ip> first");
+              return;
+            }
+            setIsProcessing(true);
+            startTimer();
+            const allObjective = args.slice(1).join(" ") || "Perform comprehensive penetration testing";
+            addMessage(MESSAGE_TYPE.SYSTEM, `\u{1F680} Starting multi-target attack on ${allTargets.length} targets`);
+            for (let i = 0; i < allTargets.length; i++) {
+              const currentTarget = allTargets[i];
+              if (agent.shouldStop()) {
+                addMessage(MESSAGE_TYPE.SYSTEM, `\u23F8 Stopped at target ${i + 1}/${allTargets.length}`);
+                break;
+              }
+              agent.setTarget(currentTarget);
+              addMessage(MESSAGE_TYPE.SYSTEM, `
+\u2501\u2501\u2501 [${i + 1}/${allTargets.length}] ${currentTarget} \u2501\u2501\u2501`);
+              forceUpdate((n) => n + 1);
+              try {
+                const session = await sessionManager2.createSession(allObjective, currentTarget);
+                addMessage(MESSAGE_TYPE.SYSTEM, `\u{1F4C1} Session: ${session.id}`);
+                agent.resume();
+                await agent.runAutonomous(allObjective);
+              } catch (e) {
+                addMessage(MESSAGE_TYPE.ERROR, `${currentTarget}: ${e instanceof Error ? e.message : String(e)}`);
+              }
+            }
+            stopTimer();
+            setIsProcessing(false);
+            setCurrentStatus("");
+            addMessage(MESSAGE_TYPE.SYSTEM, `\u2713 Multi-target attack complete`);
+            return;
+          }
           let startObjective = args.join(" ");
           const firstArg = args[0];
           if (firstArg && (firstArg.includes(".") || /^\d+\.\d+\.\d+\.\d+$/.test(firstArg))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pentesting",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "description": "Autonomous Penetration Testing AI Agent",
   "type": "module",
   "main": "dist/index.js",