pentesting 0.1.8 → 0.1.10

package/dist/index.js

@@ -1840,6 +1840,93 @@ async function searchExploits(query) {
   return searchDuckDuckGo(`${query} site:exploit-db.com OR site:github.com exploit`);
 }
 
+// src/config/agent-constants.ts
+var AGENT_STATUS = {
+  IDLE: "idle",
+  RUNNING: "running",
+  PAUSED: "paused",
+  STUCK: "stuck",
+  WAITING_INPUT: "waiting_input",
+  COMPLETED: "completed"
+};
+var PHASE_ID = {
+  RECON: "recon",
+  SCAN: "scan",
+  ENUM: "enum",
+  VULN: "vuln",
+  EXPLOIT: "exploit",
+  PRIVESC: "privesc",
+  PIVOT: "pivot",
+  PERSIST: "persist",
+  EXFIL: "exfil",
+  REPORT: "report"
+};
+var PHASE_STATUS = {
+  PENDING: "pending",
+  IN_PROGRESS: "in_progress",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var THOUGHT_TYPE = {
+  OBSERVATION: "observation",
+  HYPOTHESIS: "hypothesis",
+  PLAN: "plan",
+  ACTION: "action",
+  RESULT: "result",
+  REFLECTION: "reflection",
+  STUCK: "stuck",
+  BREAKTHROUGH: "breakthrough"
+};
+var AGENT_EVENT = {
+  // Lifecycle
+  PLUGINS_LOADED: "plugins_loaded",
+  HOOKS_LOADED: "hooks_loaded",
+  COMMANDS_LOADED: "commands_loaded",
+  MCP_SERVER_ADDED: "mcp_server_added",
+  // Execution
+  ITERATION: "iteration",
+  THOUGHT: "thought",
+  RESPONSE: "response",
+  TOOL_CALL: "tool_call",
+  TOOL_RESULT: "tool_result",
+  COMMAND_EXECUTE: "command_execute",
+  // State changes
+  TARGET_SET: "target_set",
+  PHASE_CHANGE: "phase_change",
+  AGENT_SWITCH: "agent_switch",
+  PAUSED: "paused",
+  RESUMED: "resumed",
+  RESET: "reset",
+  // Discoveries
+  FINDING: "finding",
+  CREDENTIAL: "credential",
+  COMPROMISED: "compromised",
+  // Completion
+  COMPLETE: "complete",
+  REPORT: "report",
+  ERROR: "error",
+  HINT_RECEIVED: "hint_received"
+};
+var CLI_COMMAND = {
+  HELP: "help",
+  TARGET: "target",
+  START: "start",
+  STOP: "stop",
+  FINDINGS: "findings",
+  CLEAR: "clear",
+  EXIT: "exit"
+};
+var MESSAGE_TYPE = {
+  USER: "user",
+  ASSISTANT: "assistant",
+  TOOL: "tool",
+  THINKING: "thinking",
+  ERROR: "error",
+  SYSTEM: "system",
+  RESULT: "result"
+};
+
 // src/core/agent/autonomous-agent.ts
 function toContentBlockParam(block) {
   switch (block.type) {
@@ -1923,36 +2010,36 @@ var AutonomousHackingAgent = class extends EventEmitter3 {
     try {
       const agentsDir = new URL("../../../../plugins/pentesting-core/agents", import.meta.url).pathname;
       this.pluginAgents = await loadAllAgents(agentsDir);
-      this.emit("plugins_loaded", { agents: this.pluginAgents.length });
+      this.emit(AGENT_EVENT.PLUGINS_LOADED, { agents: this.pluginAgents.length });
       await this.hookExecutor.initialize();
-      this.emit("hooks_loaded");
+      this.emit(AGENT_EVENT.HOOKS_LOADED);
       await this.commandRegistry.initialize();
-      this.emit("commands_loaded");
+      this.emit(AGENT_EVENT.COMMANDS_LOADED);
     } catch {
     }
   }
   // Add MCP server at runtime
   async addMCPServer(name, command, args) {
     await this.mcpManager.addServer(name, { command, args });
-    this.emit("mcp_server_added", { name });
+    this.emit(AGENT_EVENT.MCP_SERVER_ADDED, { name });
   }
   // Web search capabilities
   async webSearch(query) {
-    this.think("observation", `Web search: ${query}`);
+    this.think(THOUGHT_TYPE.OBSERVATION, `Web search: ${query}`);
     const results = await searchDuckDuckGo(query);
-    this.think("result", `Found ${results.length} results`);
+    this.think(THOUGHT_TYPE.RESULT, `Found ${results.length} results`);
     return results;
   }
   async searchForCVE(query) {
-    this.think("observation", `CVE search: ${query}`);
+    this.think(THOUGHT_TYPE.OBSERVATION, `CVE search: ${query}`);
     const results = await searchCVE(query);
-    this.think("result", `Found ${results.length} CVE results`);
+    this.think(THOUGHT_TYPE.RESULT, `Found ${results.length} CVE results`);
     return results;
   }
   async searchForExploits(query) {
-    this.think("observation", `Exploit search: ${query}`);
+    this.think(THOUGHT_TYPE.OBSERVATION, `Exploit search: ${query}`);
     const results = await searchExploits(query);
-    this.think("result", `Found ${results.length} exploit results`);
+    this.think(THOUGHT_TYPE.RESULT, `Found ${results.length} exploit results`);
     return results;
   }
   // Process slash command
@@ -1964,8 +2051,8 @@ var AutonomousHackingAgent = class extends EventEmitter3 {
       return `Unknown command: /${parsed.command}
 ${await this.commandRegistry.getHelp()}`;
     }
-    this.think("plan", `Executing command: /${cmd.name}`);
-    this.emit("command_execute", { command: cmd.name, args: parsed.rawArgs });
+    this.think(THOUGHT_TYPE.PLAN, `Executing command: /${cmd.name}`);
+    this.emit(AGENT_EVENT.COMMAND_EXECUTE, { command: cmd.name, args: parsed.rawArgs });
     return cmd.content;
   }
   // Switch to specialized agent
@@ -1975,8 +2062,8 @@ ${await this.commandRegistry.getHelp()}`;
     );
     if (agent) {
       this.currentAgent = agent;
-      this.think("plan", `Switching to specialized agent: ${agent.name}`);
-      this.emit("agent_switch", agent);
+      this.think(THOUGHT_TYPE.PLAN, `Switching to specialized agent: ${agent.name}`);
+      this.emit(AGENT_EVENT.AGENT_SWITCH, agent);
       return true;
     }
     return false;
@@ -1988,7 +2075,7 @@ ${await this.commandRegistry.getHelp()}`;
   // ===== State Management =====
   createInitialState() {
     return {
-      status: "idle",
+      status: AGENT_STATUS.IDLE,
       target: {
         primary: "",
         discovered: [],
@@ -2015,7 +2102,7 @@ ${await this.commandRegistry.getHelp()}`;
     return { ...this.state };
   }
   getPhaseProgress() {
-    const completed = this.state.phases.filter((p) => p.status === "completed").length;
+    const completed = this.state.phases.filter((p) => p.status === PHASE_STATUS.COMPLETED).length;
     return {
       completed,
       full: this.state.phases.length,
@@ -2032,13 +2119,13 @@ ${await this.commandRegistry.getHelp()}`;
       phase: this.state.currentPhase
     };
     this.state.thoughts.push(thought);
-    this.emit("thought", thought);
+    this.emit(AGENT_EVENT.THOUGHT, thought);
   }
   // ===== Target Setting =====
   setTarget(target) {
     this.state.target.primary = target;
-    this.think("observation", `Target Setting: ${target}`);
-    this.emit("target_set", target);
+    this.think(THOUGHT_TYPE.OBSERVATION, `Target Setting: ${target}`);
+    this.emit(AGENT_EVENT.TARGET_SET, target);
   }
   // ===== Phase Management =====
   getCurrentPhase() {
@@ -2051,21 +2138,21 @@ ${await this.commandRegistry.getHelp()}`;
       phase.status = status;
       if (status === "in_progress" && !phase.startTime) {
         phase.startTime = /* @__PURE__ */ new Date();
-      } else if ((status === "completed" || status === "failed") && !phase.endTime) {
+      } else if ((status === PHASE_STATUS.COMPLETED || status === PHASE_STATUS.FAILED) && !phase.endTime) {
         phase.endTime = /* @__PURE__ */ new Date();
       }
-      this.emit("phase_change", { phaseId, oldStatus, newStatus: status });
-      this.think("observation", `Phase status changed: ${phase.shortName} (${oldStatus} \u2192 ${status})`);
+      this.emit(AGENT_EVENT.PHASE_CHANGE, { phaseId, oldStatus, newStatus: status });
+      this.think(THOUGHT_TYPE.OBSERVATION, `Phase status changed: ${phase.shortName} (${oldStatus} \u2192 ${status})`);
     }
   }
   advanceToNextPhase() {
     const currentIndex = this.state.phases.findIndex((p) => p.id === this.state.currentPhase);
     if (currentIndex < this.state.phases.length - 1) {
       const nextPhase = this.state.phases[currentIndex + 1];
-      this.setPhaseStatus(this.state.currentPhase, "completed");
+      this.setPhaseStatus(this.state.currentPhase, PHASE_STATUS.COMPLETED);
       this.state.currentPhase = nextPhase.id;
       this.setPhaseStatus(nextPhase.id, "in_progress");
-      this.think("plan", `Advancing to next phase: ${nextPhase.shortName}`);
+      this.think(THOUGHT_TYPE.PLAN, `Advancing to next phase: ${nextPhase.shortName}`);
       this.resetStuckCounter();
       return true;
     }
@@ -2075,16 +2162,16 @@ ${await this.commandRegistry.getHelp()}`;
   checkIfStuck() {
     const currentPhase = this.getCurrentPhase();
     if (currentPhase.attempts > this.MAX_PHASE_ATTEMPTS) {
-      this.think("stuck", `[!] Rabbit hole detected: ${currentPhase.attempts} attempts in ${currentPhase.shortName} phase`);
+      this.think(THOUGHT_TYPE.STUCK, `[!] Rabbit hole detected: ${currentPhase.attempts} attempts in ${currentPhase.shortName} phase`);
       return true;
     }
     const timeSinceProgress = Date.now() - this.state.lastProgressTime.getTime();
     if (timeSinceProgress > this.STUCK_TIME_THRESHOLD) {
-      this.think("stuck", `[!] Rabbit hole detected: No progress for ${Math.round(timeSinceProgress / 6e4)} minutes`);
+      this.think(THOUGHT_TYPE.STUCK, `[!] Rabbit hole detected: No progress for ${Math.round(timeSinceProgress / 6e4)} minutes`);
       return true;
     }
     if (this.state.stuckCounter > this.STUCK_THRESHOLD) {
-      this.think("stuck", `[!] Rabbit hole detected: Same pattern ${this.state.stuckCounter} times repeated`);
+      this.think(THOUGHT_TYPE.STUCK, `[!] Rabbit hole detected: Same pattern ${this.state.stuckCounter} times repeated`);
       return true;
     }
     return false;
@@ -2103,7 +2190,7 @@ ${await this.commandRegistry.getHelp()}`;
   }
   // ===== Self Reflection =====
   async performSelfReflection() {
-    this.think("reflection", "[reflect] Starting self-reflection...");
+    this.think(THOUGHT_TYPE.REFLECTION, "[reflect] Starting self-reflection...");
     const reflectionPrompt = `
 ${SELF_REFLECTION_PROMPT}
 
@@ -2124,7 +2211,7 @@ What went wrong and what different approach should be tried?
       messages: [{ role: "user", content: reflectionPrompt }]
     });
     const reflection = response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-    this.think("reflection", reflection);
+    this.think(THOUGHT_TYPE.REFLECTION, reflection);
     return reflection;
   }
   // ===== Progress Detection =====
@@ -2133,16 +2220,16 @@ What went wrong and what different approach should be tried?
     this.state.lastProgressTime = /* @__PURE__ */ new Date();
     switch (type) {
       case "discovery":
-        this.think("breakthrough", "[target] New target discovered!");
+        this.think(THOUGHT_TYPE.BREAKTHROUGH, "[target] New target discovered!");
         break;
       case "credential":
-        this.think("breakthrough", "[cred] Credential obtained!");
+        this.think(THOUGHT_TYPE.BREAKTHROUGH, "[cred] Credential obtained!");
         break;
       case "access":
-        this.think("breakthrough", "[access] Access obtained!");
+        this.think(THOUGHT_TYPE.BREAKTHROUGH, "[access] Access obtained!");
         break;
       case "exploit":
-        this.think("breakthrough", "[exploit] Exploit successful!");
+        this.think(THOUGHT_TYPE.BREAKTHROUGH, "[exploit] Exploit successful!");
         this.state.successfulExploits++;
         break;
     }
@@ -2156,7 +2243,7 @@ What went wrong and what different approach should be tried?
     };
     this.state.findings.push(newFinding);
     this.getCurrentPhase().findings.push(newFinding);
-    this.emit("finding", newFinding);
+    this.emit(AGENT_EVENT.FINDING, newFinding);
     if (finding.severity === "critical" || finding.severity === "high") {
       this.recordProgress("discovery");
     }
@@ -2164,55 +2251,55 @@ What went wrong and what different approach should be tried?
   addCredential(cred) {
     this.state.target.credentials.push(cred);
     this.recordProgress("credential");
-    this.emit("credential", cred);
-    this.think("observation", `Credential obtained: ${cred.type} - ${cred.username || "unknown"}@${cred.source}`);
+    this.emit(AGENT_EVENT.CREDENTIAL, cred);
+    this.think(THOUGHT_TYPE.OBSERVATION, `Credential obtained: ${cred.type} - ${cred.username || "unknown"}@${cred.source}`);
   }
   addCompromisedHost(host) {
     if (!this.state.target.compromised.includes(host)) {
       this.state.target.compromised.push(host);
       this.recordProgress("access");
-      this.emit("compromised", host);
-      this.think("breakthrough", `Host compromised: ${host}`);
+      this.emit(AGENT_EVENT.COMPROMISED, host);
+      this.think(THOUGHT_TYPE.BREAKTHROUGH, `Host compromised: ${host}`);
     }
   }
   // ===== Main Autonomous Execution Loop =====
   async runAutonomous(objective) {
     if (!this.state.target.primary) {
-      this.emit("error", new Error("Target not set"));
+      this.emit(AGENT_EVENT.ERROR, new Error("Target not set"));
       return;
     }
-    this.state.status = "running";
+    this.state.status = AGENT_STATUS.RUNNING;
     this.setPhaseStatus("recon", "in_progress");
     const mainObjective = objective || `
 Target ${this.state.target.primary} - performing full penetration test.
 Goal: Deep penetration to obtain root/system privileges, extract internal data, map entire network.
 `;
-    this.think("plan", `Autonomous hacking started: ${mainObjective}`);
+    this.think(THOUGHT_TYPE.PLAN, `Autonomous hacking started: ${mainObjective}`);
     this.state.history.push({
       role: "user",
       content: mainObjective
     });
     let iteration = 0;
     const maxIterations = this.config.maxIterations;
-    while (iteration < maxIterations && this.state.status === "running") {
+    while (iteration < maxIterations && this.state.status === AGENT_STATUS.RUNNING) {
       iteration++;
       this.state.iteration = iteration;
       this.getCurrentPhase().attempts++;
       this.state.fullAttempts++;
-      this.emit("iteration", { current: iteration, max: maxIterations, phase: this.state.currentPhase });
+      this.emit(AGENT_EVENT.ITERATION, { current: iteration, max: maxIterations, phase: this.state.currentPhase });
       try {
         if (this.checkIfStuck()) {
-          this.state.status = "stuck";
+          this.state.status = AGENT_STATUS.STUCK;
           const reflection = await this.performSelfReflection();
           const shouldSkip = await this.decideNextAction(reflection);
           if (shouldSkip) {
             this.setPhaseStatus(this.state.currentPhase, "skipped");
             if (!this.advanceToNextPhase()) {
-              this.think("observation", "All phases completed or skipped");
+              this.think(THOUGHT_TYPE.OBSERVATION, "All phases completed or skipped");
               break;
             }
           }
-          this.state.status = "running";
+          this.state.status = AGENT_STATUS.RUNNING;
           this.resetStuckCounter();
           continue;
         }
@@ -2220,25 +2307,25 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
         await this.analyzeResponse(response);
         if (this.shouldAdvancePhase()) {
           if (!this.advanceToNextPhase()) {
-            this.think("observation", "[done] All phases completed!");
+            this.think(THOUGHT_TYPE.OBSERVATION, "[done] All phases completed!");
             break;
           }
         }
       } catch (error) {
         this.state.failedAttempts++;
-        this.think("result", `[-] Error: ${error.message}`);
-        this.emit("error", error);
+        this.think(THOUGHT_TYPE.RESULT, `[-] Error: ${error.message}`);
+        this.emit(AGENT_EVENT.ERROR, error);
         await this.attemptRecovery(error);
       }
     }
-    this.state.status = "completed";
+    this.state.status = AGENT_STATUS.COMPLETED;
     await this.generateFinalReport();
-    this.emit("complete", this.getSummary());
+    this.emit(AGENT_EVENT.COMPLETE, this.getSummary());
   }
   // ===== Step Execution =====
   async executeStep() {
     const contextPrompt = this.buildContextPrompt();
-    this.think("plan", "Deciding next action...");
+    this.think(THOUGHT_TYPE.PLAN, "Deciding next action...");
     const historyMessages = this.state.history.map(toMessageParam);
     const messages = [
       ...historyMessages,
@@ -2266,7 +2353,7 @@ Goal: Deep penetration to obtain root/system privileges, extract internal data,
 === Current Status ===
 Target: ${this.state.target.primary}
 Current phase: ${phase.shortName} (${phase.name})
-Phase progress: ${this.state.phases.filter((p) => p.status === "completed").length}/${this.state.phases.length}
+Phase progress: ${this.state.phases.filter((p) => p.status === PHASE_STATUS.COMPLETED).length}/${this.state.phases.length}
 Compromised hosts: ${this.state.target.compromised.join(", ") || "none"}
 
 === Discovered Services ===
@@ -2293,8 +2380,8 @@ Use report_finding tool for important discoveries.
       if (block.type === "text") {
         textResponse += block.text;
         contentBlocks.push({ type: "text", text: block.text });
-        this.think("observation", block.text.slice(0, 500));
-        this.emit("response", block.text);
+        this.think(THOUGHT_TYPE.OBSERVATION, block.text.slice(0, 500));
+        this.emit(AGENT_EVENT.RESPONSE, block.text);
       } else if (block.type === "tool_use") {
         const toolName = block.name;
         const toolInput = block.input;
@@ -2306,15 +2393,15 @@ Use report_finding tool for important discoveries.
         });
         const actionKey = `${toolName}:${JSON.stringify(toolInput).slice(0, 100)}`;
         this.trackAction(actionKey);
-        this.think("action", `[tool] Tool execution: ${toolName}`);
-        this.emit("tool_call", { id: block.id, name: toolName, input: toolInput });
+        this.think(THOUGHT_TYPE.ACTION, `[tool] Tool execution: ${toolName}`);
+        this.emit(AGENT_EVENT.TOOL_CALL, { id: block.id, name: toolName, input: toolInput });
         const result = await executeToolCall(toolName, toolInput);
         const resultType = result.success ? "result" : "result";
         this.think(
           resultType,
           result.success ? `[+] ${toolName} Success: ${result.output.slice(0, 200)}...` : `[-] ${toolName} Failed: ${result.error}`
         );
-        this.emit("tool_result", { id: block.id, name: toolName, result });
+        this.emit(AGENT_EVENT.TOOL_RESULT, { id: block.id, name: toolName, result });
         this.extractIntelligence(toolName, result);
         this.state.history.push({
           role: "assistant",
@@ -2378,14 +2465,14 @@ Use report_finding tool for important discoveries.
       passwordPatterns.forEach((pattern) => {
         const matches = result.output.match(pattern);
         if (matches) {
-          this.think("observation", `Potential credentials found: ${matches.slice(0, 3).join(", ")}`);
+          this.think(THOUGHT_TYPE.OBSERVATION, `Potential credentials found: ${matches.slice(0, 3).join(", ")}`);
         }
       });
     }
     const cveMatches = result.output.match(/CVE-\d{4}-\d+/gi);
     if (cveMatches) {
       cveMatches.forEach((cve) => {
-        this.think("observation", `CVE found: ${cve}`);
+        this.think(THOUGHT_TYPE.OBSERVATION, `CVE found: ${cve}`);
       });
     }
     if (output.includes("meterpreter") || output.includes("shell session") || output.includes("www-data") || output.includes("uid=")) {
@@ -2431,11 +2518,11 @@ Use report_finding tool for important discoveries.
   }
   // ===== Recovery Attempt =====
   async attemptRecovery(error) {
-    this.think("reflection", `Attempting recovery: ${error.message}`);
+    this.think(THOUGHT_TYPE.REFLECTION, `Attempting recovery: ${error.message}`);
     if (error.message.includes("timeout")) {
-      this.think("plan", "Timeout - retrying with shorter command");
+      this.think(THOUGHT_TYPE.PLAN, "Timeout - retrying with shorter command");
     } else if (error.message.includes("permission")) {
-      this.think("plan", "Permission error - trying different approach");
+      this.think(THOUGHT_TYPE.PLAN, "Permission error - trying different approach");
     }
   }
   // ===== Final Report Generation =====
@@ -2480,8 +2567,8 @@ ${this.state.phases.map((p) => `- **${p.shortName}**: ${p.status} (${p.attempts}
 Based on the findings, the following remediation steps are recommended:
 ${this.state.findings.filter((f) => f.severity !== "info").map((f) => `- Address: ${f.title}`).join("\n")}
 `;
-    this.setPhaseStatus("report", "completed");
-    this.emit("report", report);
+    this.setPhaseStatus(PHASE_ID.REPORT, PHASE_STATUS.COMPLETED);
+    this.emit(AGENT_EVENT.REPORT, report);
     return report;
   }
   // ===== Summary =====
@@ -2499,29 +2586,29 @@ ${this.state.findings.filter((f) => f.severity !== "info").map((f) => `- Address
   }
   // ===== User Hint Processing =====
   async processUserHint(hint) {
-    this.think("observation", `User hint: ${hint}`);
+    this.think(THOUGHT_TYPE.OBSERVATION, `User hint: ${hint}`);
     this.state.history.push({
       role: "user",
       content: `[User hint] ${hint}`
     });
     this.resetStuckCounter();
-    this.emit("hint_received", hint);
+    this.emit(AGENT_EVENT.HINT_RECEIVED, hint);
   }
   // ===== Pause/Resume =====
   pause() {
-    this.state.status = "paused";
-    this.emit("paused");
+    this.state.status = AGENT_STATUS.PAUSED;
+    this.emit(AGENT_EVENT.PAUSED);
   }
   resume() {
-    if (this.state.status === "paused") {
-      this.state.status = "running";
-      this.emit("resumed");
+    if (this.state.status === AGENT_STATUS.PAUSED) {
+      this.state.status = AGENT_STATUS.RUNNING;
+      this.emit(AGENT_EVENT.RESUMED);
     }
   }
   // ===== Reset =====
   reset() {
     this.state = this.createInitialState();
-    this.emit("reset");
+    this.emit(AGENT_EVENT.RESET);
   }
 };
 
@@ -2647,39 +2734,39 @@ var App = ({ autoApprove = false, target }) => {
     return duration;
   }, []);
   useEffect(() => {
-    addMessage("system", "Pentesting Agent initialized. Type /help for commands.");
+    addMessage(MESSAGE_TYPE.SYSTEM, "Pentesting Agent initialized. Type /help for commands.");
     if (target) {
       agent.setTarget(target);
-      addMessage("system", `Target: ${target}`);
+      addMessage(MESSAGE_TYPE.SYSTEM, `Target: ${target}`);
     }
-    agent.on("thought", (type, content) => {
-      setCurrentStatus(content.slice(0, 60));
+    agent.on(AGENT_EVENT.THOUGHT, (thought) => {
+      setCurrentStatus(thought.content.slice(0, 60));
     });
-    agent.on("tool_call", (data) => {
+    agent.on(AGENT_EVENT.TOOL_CALL, (data) => {
       const args = Object.entries(data.input).slice(0, 2).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 30) : "..."}`).join(" ");
       setCurrentStatus(`Running ${data.name}...`);
-      addMessage("tool", `\u25B6 ${data.name} ${args}`);
+      addMessage(MESSAGE_TYPE.TOOL, `\u25B6 ${data.name} ${args}`);
     });
-    agent.on("tool_result", (data) => {
+    agent.on(AGENT_EVENT.TOOL_RESULT, (data) => {
       const icon = data.result.success ? "\u2713" : "\u2717";
       const preview = data.result.output?.slice(0, 100).replace(/\n/g, " ") || "";
-      addMessage("result", `${icon} ${preview}`);
+      addMessage(MESSAGE_TYPE.RESULT, `${icon} ${preview}`);
     });
-    agent.on("iteration", (data) => {
-      setCurrentStatus(`Phase: ${data.phase} (iteration ${data.iteration})`);
+    agent.on(AGENT_EVENT.ITERATION, (data) => {
+      setCurrentStatus(`Phase: ${data.phase} (iteration ${data.current})`);
     });
-    agent.on("finding", (finding) => {
-      addMessage("system", `\u{1F3AF} [${finding.severity.toUpperCase()}] ${finding.title}`);
+    agent.on(AGENT_EVENT.FINDING, (finding) => {
+      addMessage(MESSAGE_TYPE.SYSTEM, `\u{1F3AF} [${finding.severity.toUpperCase()}] ${finding.title}`);
     });
-    agent.on("complete", () => {
+    agent.on(AGENT_EVENT.COMPLETE, () => {
       const duration = stopTimer();
-      addMessage("system", `\u2713 Complete (${duration}s)`);
+      addMessage(MESSAGE_TYPE.SYSTEM, `\u2713 Complete (${duration}s)`);
       setIsProcessing(false);
       setCurrentStatus("");
     });
-    agent.on("error", (error) => {
+    agent.on(AGENT_EVENT.ERROR, (error) => {
       stopTimer();
-      addMessage("error", error.message);
+      addMessage(MESSAGE_TYPE.ERROR, error.message);
       setIsProcessing(false);
     });
     return () => {
@@ -2690,14 +2777,14 @@ var App = ({ autoApprove = false, target }) => {
     const trimmed = value.trim();
     if (!trimmed || isProcessing) return;
     setInput("");
-    addMessage("user", trimmed);
+    addMessage(MESSAGE_TYPE.USER, trimmed);
     if (trimmed.startsWith("/")) {
       const [cmd, ...args] = trimmed.slice(1).split(" ");
       switch (cmd) {
-        case "help":
+        case CLI_COMMAND.HELP:
         case "h":
           addMessage(
-            "system",
+            MESSAGE_TYPE.SYSTEM,
             `/target <ip>     Set target
 /start [goal]    Start pentest  
 /stop            Stop operation
@@ -2706,16 +2793,16 @@ var App = ({ autoApprove = false, target }) => {
 /exit            Exit`
           );
           return;
-        case "target":
+        case CLI_COMMAND.TARGET:
         case "t":
           if (args[0]) {
             agent.setTarget(args[0]);
-            addMessage("system", `Target \u2192 ${args[0]}`);
+            addMessage(MESSAGE_TYPE.SYSTEM, `Target \u2192 ${args[0]}`);
           } else {
-            addMessage("error", "Usage: /target <ip>");
+            addMessage(MESSAGE_TYPE.ERROR, "Usage: /target <ip>");
           }
           return;
-        case "start":
+        case CLI_COMMAND.START:
         case "s":
           setIsProcessing(true);
           startTimer();
@@ -2724,39 +2811,39 @@ var App = ({ autoApprove = false, target }) => {
           try {
             await agent.runAutonomous(objective);
           } catch (e) {
-            addMessage("error", e instanceof Error ? e.message : String(e));
+            addMessage(MESSAGE_TYPE.ERROR, e instanceof Error ? e.message : String(e));
           }
           stopTimer();
           setIsProcessing(false);
           setCurrentStatus("");
           return;
-        case "stop":
+        case CLI_COMMAND.STOP:
           agent.pause();
           stopTimer();
-          addMessage("system", "Stopped.");
+          addMessage(MESSAGE_TYPE.SYSTEM, "Stopped.");
           setIsProcessing(false);
           setCurrentStatus("");
           return;
-        case "findings":
+        case CLI_COMMAND.FINDINGS:
         case "f":
           const findings = agent.getState().findings;
           if (findings.length === 0) {
-            addMessage("system", "No findings.");
+            addMessage(MESSAGE_TYPE.SYSTEM, "No findings.");
           } else {
-            findings.forEach((f) => addMessage("system", `[${f.severity}] ${f.title}`));
+            findings.forEach((f) => addMessage(MESSAGE_TYPE.SYSTEM, `[${f.severity}] ${f.title}`));
           }
           return;
-        case "clear":
+        case CLI_COMMAND.CLEAR:
         case "c":
           setMessages([]);
           return;
-        case "exit":
+        case CLI_COMMAND.EXIT:
         case "quit":
         case "q":
           exit();
           return;
         default:
-          addMessage("error", `Unknown: ${cmd}`);
+          addMessage(MESSAGE_TYPE.ERROR, `Unknown: ${cmd}`);
           return;
       }
     }
@@ -2765,9 +2852,9 @@ var App = ({ autoApprove = false, target }) => {
     setCurrentStatus("Thinking...");
     try {
       await agent.processUserHint(trimmed);
-      addMessage("system", "Hint received.");
+      addMessage(MESSAGE_TYPE.SYSTEM, "Hint received.");
     } catch (e) {
-      addMessage("error", e instanceof Error ? e.message : String(e));
+      addMessage(MESSAGE_TYPE.ERROR, e instanceof Error ? e.message : String(e));
     }
     stopTimer();
     setIsProcessing(false);
@@ -2780,7 +2867,7 @@ var App = ({ autoApprove = false, target }) => {
         stopTimer();
         setIsProcessing(false);
         setCurrentStatus("");
-        addMessage("system", "Interrupted.");
+        addMessage(MESSAGE_TYPE.SYSTEM, "Interrupted.");
       } else {
         exit();
       }
@@ -2788,15 +2875,15 @@ var App = ({ autoApprove = false, target }) => {
   });
   const getStyle = (type) => {
     const styles = {
-      user: { color: THEME.text.accent, prefix: "\u276F" },
-      assistant: { color: THEME.text.primary, prefix: "\u25C8" },
-      tool: { color: THEME.text.muted, prefix: " ", dim: true },
-      result: { color: THEME.text.muted, prefix: " ", dim: true },
-      thinking: { color: THEME.status.running, prefix: "\u25CB" },
-      error: { color: THEME.status.error, prefix: "\u2717" },
-      system: { color: THEME.text.muted, prefix: "\u2022" }
+      [MESSAGE_TYPE.USER]: { color: THEME.text.accent, prefix: "\u276F" },
+      [MESSAGE_TYPE.ASSISTANT]: { color: THEME.text.primary, prefix: "\u25C8" },
+      [MESSAGE_TYPE.TOOL]: { color: THEME.text.muted, prefix: " ", dim: true },
+      [MESSAGE_TYPE.RESULT]: { color: THEME.text.muted, prefix: " ", dim: true },
+      [MESSAGE_TYPE.THINKING]: { color: THEME.status.running, prefix: "\u25CB" },
+      [MESSAGE_TYPE.ERROR]: { color: THEME.status.error, prefix: "\u2717" },
+      [MESSAGE_TYPE.SYSTEM]: { color: THEME.text.muted, prefix: "\u2022" }
     };
-    return styles[type] || styles.system;
+    return styles[type] || styles[MESSAGE_TYPE.SYSTEM];
   };
   const state = agent.getState();
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [

package/package.json

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